Exportando gráficos en dia a pdflatex

1. Hacé tu gráfico en dia
2. Exportarlo como "LaTeX PGF macros"
3. En el principio de tu .tex poné:

\usepackage{tikz}

4. En el lugar donde quieras poner tu caption poné

   \begin{figure}
   \centering
   \input{archivo_exportado_de_dia.tex}
   \caption{Acá va el caption}
   \label{aca_va_la_label}
   \end{figure}
   

5. Compilá el .tex principal con pdflatex
6. Miralo con tu visor de pdfs favorito

Happy hacking,

Aureliano.

Como ven los fanas de un lenguaje a los otros

Mirar lambda the ultimate es siempre interesante. Y esta vez me crucé con una perlita que quiero compartir con ustedes:

Segundo advisory

Ayer salió mi segundo advisory. Lo que encontramos con Manuk es que parte administrativa de la aplicación LanDesk Manager tiene un cross-site request forgery que hace que si enganchás a un administrador se pueda hacer un cross-site scripting no persistente y, aún más divertido, hacer un OS command injection.
Aún más divertido, es que se puede usar modprobe y cargar módulos de kernel de linux que uplodee usando el command injection.
Más detalles en la página de Core.
Happy hacking,
Aureliano

Simplificando

Ayer me di cuenta que no necesito rehacer los classloaders de java para cargar scripts de JavaScript, ya que puedo usarlos y son todo lo flexibles que necesito (y más). Inclusive, si por una de esas casualidades llegara a hace falta, creo que puedo hacer uno en rhino y todo. Por lo tanto decidí que mi lógica para cargar módulos tenía una indirección de más (la lista de loaders) y lo cambié para que use el classloader y listo. Fíjense en la nueva implementación de loadMod y como se simplificó el uso de los loaders.
En la versión del código que estoy usando ahora, también hice que los módulos se carguen un toque distintos para que haya mejores stack-traces (ese cambio está en la función require). Bueno, abajo pongo el código:

/*  
 * Does not support relative paths (yet?).
 * Can be invoked by several threads.
 * 
 * Uses the classloader to fetch js modules.
 */
var require = function (id) {
 
 try {

  require.lock.lock() // Avoid threading issues while loading modules.
  
  if (!require.modules[id]) {

   var modCode = require.loadMod(id)

   var exports = {}
   require.modules[id] = exports
   var module = {
    id : id
   }
   
   var context = {
    exports: exports,
    module: module,
   }
   
   if(!modCode) {
    throw new require.RequireError(id, "module not found")
   }

   org.mozilla.javascript.Context.getCurrentContext().evaluateString(
    context, 
    modCode,
    id,
    1,
    null
   )
   /*
   Old style invocation, should work in the browser but has worst error messages.
   
   var f = new Function("require", "exports", "module", modCode)
   f.call(context, require, exports, module) */
  }

  return require.modules[id]
 } catch (x) {
  if (x instanceof require.RequireError) {
   throw x
  } else {
   throw new require.RequireError(id, x)
  }
 } finally {
  require.lock.unlock()
 }
}

require.loaders = []
require.modules = {}
require.lock = new java.util.concurrent.locks.ReentrantLock()

var RequireErrorProto = {}

require.RequireError = function(moduleId, cause) {
 this.moduleId = moduleId
 this.cause = cause
 
}
require.RequireError.prototype = RequireErrorProto
require.RequireError.prototype.toString = function() {
 return "Error loading " + this.moduleId + ( this.cause ? ". Cause: " + this.cause : "" )
}
require.RequireError.prototype.name = "RequireError"

require.load = function(path) {
 return java.lang.Class.forName("java.lang.String").getResourceAsStream(path)
}

require.loadMod = function(id) {
 function path(id) {
  return "/" + id + ".js"
 }
 
 function readFromStream(stream) {
  var io = java.io
  var reader = new io.BufferedReader( new io.InputStreamReader(stream) )
  try {
   var stringBuffer = new java.lang.StringBuffer()
   
   var line = ""
   while( line = reader.readLine()) {
    stringBuffer.append(line)
    stringBuffer.append("\n")
   }
   
   return stringBuffer.toString()
  } finally {
   reader.close()
  }
 }

 var stream = require.load(path(id))
 if (!stream) { return null }
 
 return readFromStream(stream)
}

/**
 * Resets the module cache. 
 * 
 * It will reload all the modules. Old modules referenced will still be working.
 */
require.reset = function() {
 try {
  require.lock.lock()
  require.modules = {}
 } finally {
  require.lock.unlock()
 }
 
}

Este cambio también simplifico el RhinoServlet, y ahora toma sus scripts del classpath también.

Happy hacking,
Aureliano

Parseando CSVs con una expresión de JavaScript

Para parsear un CSV con datos numéricos hay que hacer esto:

text.split("\n").map( function(r){ 
  return r.split(",").map( function(d) { 
    return parseFloat(d)
  } ) 
} )

Esto solo anda si tu intérprete de JavaScript tiene Array.prototype.map definido. Sino antes de eso tenés que definirlo así:

Array.prototype.map = Array.prototype.map || function( f ) {
  var r = []
  for (var i=0; i<this.length; i++) {
    r[i] = f(this[i])
  }
  return r
}

Aure x 8

By Futo & Albinoni.

Generando xhtml con e4x

Primero hay que setear el namespace por default:

default xml namespace = "http://www.w3.org/1999/xhtml"

Para generar elementos, uso esta función:

function elem(name) { return <{name} /> }

Para setear un attributo cualquiera esta función:

function attr(elem, key, value) { elem["@"+key] = value }

Y puedo usar elem.appendChild para agregar como hijo de un elemento otro o un texto como string que es escapado.

Happy hacking,
Aureliano.

Entrada de BibTeX en Google Scholar

Si estás logueado en Google, podés setear Google Scholar para que te muestre las entradas de bibtex.
Para eso tenés que ir a Scholar Preferences -> Bibliography Manager y elegir Show links to import citations into BibTeX.

Happy hacking,
Aureliano

(Sacado de acá)

Implementación de require en Rhino

Hoy estuve hackeando un toque y modifiqué el RhinoServlet que les mostré en este post para poder tener módulos en Javascript. El API que hice es un subset de lo definido en CommonJS. En particular, soporta require pero no los paths relativos de módulos (o sea, los que empiezan con . o ..). También le puse a todo un lock para que pueda usarse en un entorno concurrente, pero si un módulo tarda mucho en cargarse puede llegar a ser un problema.
Lo que me parece más interesante de mi prototipo es que se pueden agregar fácilmente nuevos loaders de módulos de JavasScript. Ya vienen por defecto loaders para cargar desde el classpath y desde la webapp, pero si quieren poder poner sus módulos en /WEB-INF/example, alcanza con agregar una línea en init.js:

require.loaders.push( require.stdLoader(servlet.servletContext, "/WEB-INF/example/"))

Bueno, basta de cháchara, acá está la versión modificada del RhinoServlet:

package aure.jslib;

import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.mozilla.javascript.Context;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;

public class RhinoServlet extends HttpServlet {
 private static final long serialVersionUID = 1L;
 private Scriptable initialScope = null;
 
 public void runJs(Context cx, String scriptLocation, Scriptable scope) throws IOException {
  
  InputStream is = this.getClass().getResourceAsStream(scriptLocation);
  if( is == null) {
   is = this.getServletContext().getResourceAsStream("/WEB-INF/js/" + scriptLocation);
  }
  Reader jsReader = new InputStreamReader(is);
  
  cx.evaluateReader(scope, jsReader, scriptLocation, 1, null);
 }
 
 public static void addJavaObjectToScope(Scriptable scope, String name, Object obj) {
  ScriptableObject.putProperty(scope, name, Context.javaToJS(obj, scope) );
 }
 
 @Override
 public void init(ServletConfig config) throws ServletException {
  super.init(config);
  Context cx = Context.enter();
  try {
   Scriptable scope = cx.initStandardObjects();
   addJavaObjectToScope(scope, "servlet", this);
   addJavaObjectToScope(scope, "config", config);
   
   this.runJs(cx, "initRequire.js", scope);
   this.runJs(cx, "init.js", scope);
   
   this.initialScope = scope;
  } catch (IOException e) {
   throw new ServletException(e);
  } finally {
   Context.exit();
  } 
 }
 
 @Override
 protected void service(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  Context cx = Context.enter();
  try {
   Scriptable scope = cx.initStandardObjects();
   scope.setParentScope(this.initialScope);
   
   addJavaObjectToScope(scope, "request", request);
   addJavaObjectToScope(scope, "response", response);
   
   this.runJs(cx, "start.js", scope);
  } finally {
   Context.exit();
  }
 }
}

Noten que toqué el init para que agregue el require y cambié la forma de levantar javascript. Por otro lado este es el javascript en initRequire.js, que tiene la implementación del require:

/* Based on http://www.davidflanagan.com/demos/require.js
 * but heavily modified.
 *  
 * Does not support relative paths (yet?).
 * Can be invoked by several threads.
 * 
 * Uses the servletContext and the classloader to fetch js modules.
 */
var logger = java.util.logging.Logger.getLogger("sarasa")

var require = function (id) {
 
 try {

  require.lock.lock() // Avoid threading issues while loading modules.
  
  if (!require.modules[id]) {

   var modText = require.loadMod(id)

   var context = {}
   var exports = {}
   require.modules[id] = exports
   var module = {
    id : id
   }

   var f = new Function("require", "exports", "module", modText)
   f.call(context, require, exports, module)
  }

  return require.modules[id]
 } catch (x) {
  throw new Error("Can't load module: " + id + ": " + x)
 } finally {
  require.lock.unlock()
 }
}

require.loaders = []
require.modules = {}
require.lock = new java.util.concurrent.locks.ReentrantLock()
require.loadMod = function(id) {
 var modText = null
 var i = 0
 while (modText == null && i < require.loaders.length) {
  modText = require.loaders[i](id)
  i++
 }
 return modText
}

// Setup loaders for files in the classpath, files in WEB-INF and files in the
// web-app (usually served to the client)
require.stdLoader = function(source, prepend) {
 // Support functions
 function readFromStream(stream) {
  var io = java.io
  var reader = new io.BufferedReader( new io.InputStreamReader(stream) )
  var stringBuffer = new java.lang.StringBuffer()
  
  var line = ""
  while( line = reader.readLine()) {
   stringBuffer.append(line)
   stringBuffer.append("\n")
  }
  
  return stringBuffer.toString()
 }
 
 function path(id) {
  return prepend + id + ".js"
 }
 
 var f = function(id) {
  var stream = source.getResourceAsStream(path(id))
  return stream ? readFromStream(stream) : null
 }
 
 return f

}

require.initStdLoaders = function() {
 // classpath loader
 require.loaders.push( this.stdLoader(servlet["class"], "/") )
 
 // web-app context loader
 require.loaders.push( this.stdLoader(servlet.servletContext, "/") )
}

require.initStdLoaders()

Empecé a hacer esto mirando el código en http://www.davidflanagan.com/demos/require.js pero al final quedó bastante distinto, sobre todo porque tiene la opción de tener muchos loaders.
Las cosas que me quedan para hacer son hacer que acepte paths relativos (que para que sea thread-safe hace falta que haga algunos truquitos) y hacer que en vez de usar

   var f = new Function("require", "exports", "module", modText)
   f.call(context, require, exports, module)

para invocar el módulo haga algo usando el API de rhino para poder tener errores donde aparezca el nombre del módulo y el número de línea si hubo algún problema.

Escucho comentarios y sugerencias.

Happy hacking,
Aureliano.

Eclipse plug-in para app-engine

¿Por qué te negás a usar dependencias de otros proyectos de eclipse?
¿Por qué no recompilás bien cuando está corriendo el web-server en modo debug y uso resources de adentro del classpath?

Bueno, por ahora son 2 problemas que creo poder "workarroundear".

Happy hacking,
Aureliano.

2 placas y default gateway

Hoy estuve configurando una VM con ubuntu que tiene una placa en modo bridged por DHCP y otra host-only estática. El problema que tuve fue que no encontraba la forma que la ruta por default sea la ruta por default que informa el dhcp. La solución que encontré fue hacer que la métrica de la ruta por default de la ip estática sea más grande.

Este es el archivo /etc/network/interfaces que terminé usando:

auto lo eth1 eth0
iface lo inet loopback

iface eth0 inet dhcp

iface eth1 inet static
        address 172.17.17.16
        netmask 255.255.255.0
        network 172.17.17.0
        broadcast 172.17.17.255
        gateway 172.17.17.1
        metric 200

Y la posta está en la última línea.

Probé sacar la entrada de gateway y agregar una entrada borrando la ruta que me sobraba (up route del default gw 172.17.17.1) y no funcionó.

Se les ocurre alguna otra forma de arreglar esto?

Happy hacking,
Aureliano.

2 servlets para correr javascript

Estuve con algo de tiempo y me puse a probar como hacer para ejecutar JavaScript en el server. E hice 2 implementaciones (o sea, 2 servlets programados en Java). La primera que hice usa javax.script (que viene por defecto en Java 6) y me parece que el API es más cómoda pero tiene 2 limitaciones que no me gustaron, no se puede heredar de clases Java en JavaScript y no encontré cómo hacer para bindear un método de Java a JavaScript. Este es el código:

package aure;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;

import javax.script.Bindings;
import javax.script.ScriptContext;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class JsServlet extends HttpServlet {
 private static final long serialVersionUID = 1L;

 private ScriptEngine jsEng = new ScriptEngineManager()
   .getEngineByName("js");
 private Bindings initBindings = this.jsEng
   .getBindings(ScriptContext.ENGINE_SCOPE);

 public JsServlet() {
  super();
 }

 @Override
 public void init(ServletConfig config) throws ServletException {
  try {
   super.init(config);

   this.initBindings.put("config", config);
   this.initBindings.put("servlet", this);

   this.runJs("init.js", this.initBindings);
  } catch (ScriptException e) {
   throw new ServletException("Error running init.js", e);
  }
 }

 public void runJs(String scriptLocation, Bindings bindings)
   throws ScriptException {
  Reader jsReader = new InputStreamReader(this.getServletContext()
    .getResourceAsStream(scriptLocation));

  this.jsEng.eval(jsReader, bindings);
 }

 protected void service(HttpServletRequest request,
   HttpServletResponse response) throws ServletException, IOException {

  try {
   Bindings bindings = jsEng.createBindings();
   bindings.putAll(this.initBindings);
   bindings.put("request", request);
   bindings.put("response", response);
   
   this.runJs("start.js", bindings);
  } catch (ScriptException e) {
   throw new ServletException("Error running javascript", e);
  }
 }

}

La segunda usa rhino bajado desde mozilla y por lo tanto no tiene esas limitaciones, pero el API para embeber JavaScript en Java es más fea. Acá está el código de la segunda versión:

package aure;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.mozilla.javascript.Context;
import org.mozilla.javascript.Scriptable;
import org.mozilla.javascript.ScriptableObject;

public class RhinoServlet extends HttpServlet {
 private static final long serialVersionUID = 1L;
 private Scriptable initialScope = null;
 
 public void runJs(Context cx, String scriptLocation, Scriptable scope) throws IOException {
  Reader jsReader = new InputStreamReader(this.getServletContext()
    .getResourceAsStream("/WEB-INF/js" + scriptLocation));
  
  cx.evaluateReader(scope, jsReader, scriptLocation, 1, null);
 }
 
 public static void addJavaObjectToScope(Scriptable scope, String name, Object obj) {
  ScriptableObject.putProperty(scope, name, Context.javaToJS(obj, scope) );
 }
 
 @Override
 public void init(ServletConfig config) throws ServletException {
  super.init(config);
  Context cx = Context.enter();
  try {
   Scriptable scope = cx.initStandardObjects();
   addJavaObjectToScope(scope, "servlet", this);
   addJavaObjectToScope(scope, "config", config);
   
   this.runJs(cx, "/init.js", scope);
   
   this.initialScope = scope;
  } catch (IOException e) {
   throw new ServletException(e);
  } finally {
   Context.exit();
  } 
 }
 
 @Override
 protected void service(HttpServletRequest request, HttpServletResponse response)
   throws ServletException, IOException {
  Context cx = Context.enter();
  try {
   Scriptable scope = cx.initStandardObjects();
   scope.setParentScope(this.initialScope);
   
   addJavaObjectToScope(scope, "request", request);
   addJavaObjectToScope(scope, "response", response);
   
   this.runJs(cx, "/start.js", scope);
  } finally {
   Context.exit();
  }
 }
}

Ambas versiones ejecutan WEB-INF/js/init.js cuando se carga el servlet (tiene bindeados el servlet y la configuración del servlet) y WEB-INF/js/start.js cuando se atiende un pedido (agrega a los bindings lo que se haya puesto en init.js, el servlet, la configuración, el request y el response.

La idea de todo esto es ponerme las pilas e implementar las cosas que dije en este post hace casi 3 años, ya que ahora parece que se está poniendo de moda usar JavaScript.

Espero que les parezca interesante, me voy a dormir.

Happy hacking,
Aureliano.

En el Burj Dubai, arriba de todo

Este video es increíble.

Cómo me echaron de facebook

Update: Automated english translation

Esta es la lista de eventos que pasaron hasta que me echaron de Facebook:

1. 2007-11-10: Primera invitación a facebook recibida por mail
   
2. 2009-09-27: Me suscribo a facebook
3. 2009-09-30: Creo el grupo "Destruyendo facebook desde adentro"
4. 2009-10-04: Publicito el grupo en un post de mi blog.
5. 2009-10-17: Me linkea vivalinux. Entran más de 500 personas al blog en 2 días. El post del punto anterior es trolleado.
6. 2009-10-18: Sin ningún tipo de aviso bloquean mi cuenta en facebook.
7. 2009-10-19: Empieza la seguidilla de mails de/a facebook. El primero es este: "I've checked out on the links of the http://www.facebook.com/help.php?page=45 page and I didn't violate any rules.
   
   Can you inform me why the account was disabled?
   
   Thanks in advance,
   Aureliano Calvo."
8. 2009-10-22: Contesta facebook (enfasis mío):"Hi Aureliano,
   
   Fake accounts are a violation of our Statement of Rights and Responsibilities. Facebook requires users to provide their real first and last names. Impersonating anyone or anything is prohibited. Unfortunately, we will not be able to reactivate this account for any reason. This decision is final.
   
   Thanks for your understanding,
   
   Johanna
   User Operations
   Facebook"
9. 2009-10-22: Contesto yo (enfasis mío):"Hi,
   I've been falsely accused of impersonating someone else and this is just not true. I'm Aureliano Calvo, this is my e-mail and you can google for me. I can also provide several proofs of my identity and I'm willing to send photographs of my driver license, my passport or my identity card.
   
   Can you reactivate the account?
   
   Aureliano."
10. 2009-10-23: Vuelve facebook :"Hi Aureliano,
    
    Unfortunately, your account has been permanently disabled for violating Facebook's Statement of Rights and Responsibilities. We will not be able to reactivate it for any reason, nor will we provide further explanation of your violation or the systems we have in place. This decision is absolutely final.
    
    Thanks,
    
    Johanna
    User Operations
    Facebook"
11. 2009-11-21: Pido por mail que borren todos mis datos de facebook:"I would like to have removed all my data from the facebook servers (generated from the account asociated with this e-mail).
    
    Thank you very much in advance,
    Aureliano Calvo"
12. 2009-11-25: Contesta facebook sobre la remoción de datos:"Hi Aureliano,
    
    Facebook users have the option to either deactivate or delete their accounts. The differences between the two options are described below.
    
    If you deactivate your account, your profile and all information associated with it are immediately made inaccessible to other Facebook users. What this means is that you effectively disappear from the Facebook service. However, we do save your profile information (friends, photos, interests, etc.), so if you want to reactivate at some point, your account will look just the way it did when you deactivated. Many users deactivate their accounts for temporary reasons and expect their information to be there when they return to the service. You can deactivate your account through the "Deactivate Account" link on the Account page.
    
    If you do not think you will use Facebook again and you would like to delete your account, you can do this yourself by navigating to the following page:
    
    http://www.facebook.com/help/contact.php?show_form=delete_account
    
    Please keep in mind that once your account is deleted, you will not be able to reactivate the account or retrieve any of the content or information you have added.
    
    If you are currently unable to access your account, you will need to reset your password in order to log in. In order to do so, click the "Forgot your password?" link that appears above the field where you would normally enter your password. Entering your login email address on the next page will cause a new password to be sent to that email address. Once you receive your new password and can log in, you can deactivate or delete your account using the steps outlined above. We apologize for any inconvenience this may cause.
    
    Thanks for contacting Facebook,
    
    Brett
    User Operations
    Facebook"
13. 2009-11-25: Contesto que no puedo porque deshabilitaron la cuenta:"I've requested that all my data should be removed from the facebook servers by email because my account has been disabled.
    Please remove all my data from the facebook system.
    
    Thank you very much,
    Aureliano Calvo."
14. 2009-11-29: Me dicen que me joda que se quedan con todos los datos:"Hi Aureliano,
    
    When an account is disabled, the profile and all information associated with it are immediately made inaccessible to other Facebook users. What this means is that you effectively disappear from the Facebook service. In addition, Facebook does not use information associated with disabled accounts.
    
    Unfortunately, for safety and security reasons, we cannot delete from our servers information associated with disabled accounts. We also cannot grant you access to a disabled account to retrieve content from it, nor can we provide you with any content that was associated with this account. We apologize for any inconvenience this may cause. This decision is final.
    
    Thanks for your understanding,
    
    Brett
    User Operations
    Facebook"

Conclusiones:

• Facebook contesta en tiempo y forma los pedidos por mail.
  
• Facebook no identifica a las personas que contestan y no toma responsabilidades.
  
• Facebook echa gente que no viola sus términos y condiciones (el punto que dicen que violé es mentira)
• Facebook se niega a dar información sobre que hiciste mal (probablemente para cubrirse del punto uno) y encima lo hacen mal (como se ve en el punto anterior).
• Facebook se niega a borrar los datos de la gente que echa (cosa que, hasta donde yo sé, es ilegal en Argentina).

O sea, mejor irse lo antes posible de ahí. No dejes que los mercaderes de relaciones te dominen.

Happy hacking,
Aureliano.

Deshabilitando autoindent de () en vim

Para editar html con javascript con algo más de onda en gvim adopté el siguiente seteo:

:set inde=
:set ai

Para más detalles mirá acá.

Happy hacking,
Aureliano.

Invitaciones para Google Wave

¿Querés una invitación para Google Wave?

Avisame y te la mando (tengo 16 para repartir).

Seguridad nacional

Esto le pasó ayer a un compañero de trabajo. Espero que sirva para que sepamos que no hay que creer todo lo que pasa en la tele:

Ayer fue al super (disco)  a buscar la compra que habia hecho antes de
ayer ya que me avisaron que los empleados del delivery estaban de paro
por un reclamo sindical. cuando estoy llegando veo que en la esquina hay
una especia de muchedumbre de 20-30 personas y una camara de TV. No doy
bola y paso de largo hasta el super, que encuentro cerrado, en las
puertas de vidrio habia pagadas que decia qu ella empres ales mando la
policia a los que estaban reclamando para "apretarlos" y por ese se
metieron adentro y cerraron. Digo.. "uh que mal" y me voy pensando que
la muchedumbre de la esquina tendra algo que ver con eso. cuando llego a
la esquina y presto atencion a lo que pasa me doy cuenta que en realidad
hay 20-30 energumenos en chomba, camisa rosa+sweater al cuello y/o
vestido largo y ollas de fondue gritandole a la camara "seguridad!
seguridad!"  mientras esgrimen cartelitos escritos prolijamente con
marcador con la palabra en cuestion ("seguridad"). Detras de todos
ellos, sentado en el piso esta durmiendo  un señor de entre 50-60 años
que vive en la calle en esa esquina desde hace una semanas. Los
protestantes lo ignoran olimpicamente, pero el señor se despierta y
percibe que hay algun quilombo y desde el piso se une a los canticos al
tiempo que ademas aplaude (!?)

Me abro paso vocifereando que son todos unos payasos mediaticos (como
osvaldo pagani) pero a nadie parece importarle o molestarle lo que digo
o hago (que lastima! ya que estan todos hipnotizados cantando su mantra
a la camara.

Minutos despues cuando llego a casa me dicen que en el noticiero de
America transmitian en vivo una "protesta de los vecinos de palermo"
demandando mas seguridad o algo asi.

Media hora mas tarde cuando paso otra vez por la esquina paseando al
perro "los vecinos de palermo" no estan mas (el noticiero de america ya
termino) pero sigue estando el señor que vive en  la esquina condiciones
de "seguridad" bastante precarias (hasta tanto no se entere la UZZEP).

Alguien vio algo de esto en el noticiero de America ayer? que dijeron?

Happy hacking,
Aureliano.

Firewall, Windows 7 y guests bridgeados de VMWare

Si dejo el firewall de Windows 7 activado filtra las conexiones entrantes a las VMs del VMWare Server que están conectadas en modo "bridged" a la red. No sé el ip del guest ya que se obtiene por DHCP. Si apago el firewall, las conexiones entrantes llegan hasta las VMs.

Saben como hacer para dejar el firewall prendido pero que las conexiones que van a los guests en modo bridged pasen sin ser filtradas? Qué reglas tengo que agregar/sacar?

Muchas gracias,
Aureliano

Como facebook cuida tu privacidad

Vía slashdot.

Una mina con tratamiento por depresión en Canadá le niegan el tratamiento porque tiene fotos en la playa y en una fiesta en facebook (en una cuenta "lockeada"). Más detalles ver acá.

Esperemos que no se mate por esto,
Aureliano.

Visualizando más

En este post prometí que iba a contar que cosas vi en VisWeek 2009. Y como lo prometí, aunque un poco tarde acá pongo mis notas de la conferencia (tienen mezcla con inglés):

Domingo 11:

8:30am
* Keynote: Bill Cheswick
*"Visualization is about coolness"
* Lots of developments. But almost nothing in the industry

Problemas:

* Layout arbitrario
* La evolución no es clara
* Las cosas que se sacan no se muestran
* Destruyen el contexto

Usa minimum distance spanning trees todo el tiempo para mostrar cosas aunque descarta el 30-40% de las conexiones.

How do you measure security?
* Generals and CIOs want to know.
Trusecure. Always and human in a step.

Network Access Security: contar cantidad de puertos abiertos
privilege scalation: programas que corren como root desde un usuario normal.

Parte difícil, como hacer los reportes.

2D sin tiempo -> 3D para el tiempo?

Ninguna buena visualización buena de IPv6


--------------------------------------------------------------------
Sesión de visualización de redes
10:30am

Visualization of complex attacks.
* Desde el pto de vista del sysadmin.
* Ataque simple: Una acción
* Ataque complejo: combinación de los anteriores
* DDNS
* "Multi-step"
* Worm propagation
* Interesante: las líneas hacen un "fade-out" con el tiempo. Las cosas nuevas son menos transparentes.
* El IDS informa que ataques simples pertenecen al mismo ataque complejo.

OverFlow: An Overview Visualization for network analisis
FloVis -> http://www.flovis.net

Security visualization tools and ipv6 addresses
* Demasiadas direcciones (128 bits)
* La mayoría de las visualizaciones no bancan ipv6
* muestra cambios en headers 4->6
* Se enfoca en "process and reformat" y "display"
* Muestra las comunicaciones con un scatter plot
* Le da un índice ordenado a cada dirección
* Usa la estructura de la dirección para agrupar direcciones
* Treemap (no me gusta, parece muy "cluttereado":
* Color: tipo de paquete (tcp, udp, etc)
* Tamaño: volumen de tráfico

1:00p
Malware and forensics
A visual Analytic framework for Exploring Relationships in Textual Content of Digital Forensics Evidence
Muestra como indexan el disco rígido y después filtran para ir buscando cosas en el disco rígido

Visual Analysis of Malware Behaviour Using Treemaps and Thread Graphs
CWSandbox.org
* Analisis automático de malware porque les mandan como 4000 ejemplos todos los días.
* Hacen un treemap con syscalls clasificados por tipo c/ color y cantidad de llamadas en el tamaño.
* El análisis es dinámico (o sea, ejecutan el malware).
* Por eso no los jode tanto la ofuscación
* Pueden detectar pdfs "malvados" mirando los treemaps (o clusterizando los datos).

Visualizing Compiled Executables for Malware Analysis
http://www.offensivetechnology.net (VERA)
* Dibuja los basic blocks que se ejecutan (todos, también los que se generan dinámicamente)
* Arma el grafo de los basic blocks
* les da más peso a los basic blocks que más se ejecutan
* por eso los loops que más se ejecutan quedan más grandes.
* pone diferentes colores a los basic blocks en función de cómo se generan
(ej: en el ejecutable en una sección de código,
en el ejecutable en una sección de datos,
generado dinamicamente,
etc)

2:30p
Users and Usability
Visualizing Cyber Security: Usable Workspaces
* Los analistas se quejan de que no pueden interactuar con los datos.
* Usan muuuuuuuuuuucha definición (10240x3200) y pueden mostrar simultáneamente los datos y los patrones que se forman en
alto nivel.
* History trees. Parecen como los branches en un control de versiones o algo así.

Visualization is Better! A Comparative Evaluation
http://tnv.sf.net vs ethereal en newbies
* Controlled experiment comparing two tools
* http://vizsec.org/datasets/

4:45p
Visualizing Keyboard Pattern Passwords
* Muestra como mostrar que teclas apretaron con una secuencia de reglas sobre como dibujarlos.
* Encontraron patrones mirando los passwds de a 25 (500 en total)
* Generaron diccionario con algunos patrones (500K passwords)
* Con ese diccionario crackeron passwds de verdad que John The Ripper no encontró

Visualizing Firewall Configurations Using Created Voids
Espacio:
5 dimensiones escalares (host1, port1, protocol, host2, port2) y un valor categorico (allow, deny).
regla:
(min_max de (host1, port1, protocol, host2, port2), (allow|deny))
Usa paralell coordinates :( (problemas de oclusión)

Panel (Visualization + Security = Science?):
Fue una pedorrada

Lunes 12:
Keynote VAST.
Storytelling.
Contó como es la estructura de un cuento clásico (introducción, nudo y desenlace), el camino del héroe (los 12 pasos que siguen casi todos los libros y películas) y dio una heurística para darse cuenta si algo es una buena historia o no. La misma consiste en si es posible responder estas 4 preguntas facilmente:
1. Quién es el héroe?
2. Qué quiere el héroe?
3. Qué impide que el héroe lo consiga?
4. Qué hace el héroe para solucionar el problema?
El chabón afirma que todos tenemos una habilidad natural para entender cuentos, y que por eso es bueno organizar las visualizaciones y presentaciones en forma de cuento.

VAST
Multidimentional Data session

A framework for uncertainty-aware visual analytics
Proponer manejar la incertidumbre todo a lo largo del pipeline de procesamiento de datos. Puede ser que los datos vengan con "incertidumbre" o que las transformaciones agreguen incertidumbre. Al final muestra la incertidumbre de varias maneras. Ej: color (segun que variable introduce mas incerteza), transparencia (para esconder datos menos confiables), o desagregando (pero solo para pocos datos)

Combining automated analysis and visualization techniques for efective exploration of high-dimentional data
Intenta detectar automáticamente que visualización de los datos es mejor. Creo que puede servir para mostrarle al usuario automáticamente vistas de datos que tengan algún sentido (muestran en scatter plots y paralell coordinates). También dicen que vistas muestran mejor una categorización dada.

Two-stage framework for visualization of clustered high dimentional data.
Hace algo parecido que la charla de arriba pero proyectando muchas dimensiones en 2 o 3.

Model space visualization for multivariate linear trend discovery.
Muestra una técnica manual para encontrar correlaciones lineales de dimensiones cuando hay muchas dimensiones

Martes 13:
Vast. Text analytics session.

LSAView: A tool for visual exploration of latent semantic modelling.
Sirve para clasificar documentos en función del tema. Visualiza el documento para que un analista decida si el clustering está bien.

Parallel tag clouds to explore and analyze faceted text corpora.
Analizan fallos de cortes EEUUenses. POnen las palabras que son más comunes en un documento y menos comunes en el resto (Dunning's log likehood). Ponen los tags con tamaño en gráfico de paralell coordinates. Parece interesante.

Describing story evolution from dynamic information streams.
No me gustó. Muestra como intentan detectar historias que se extienden a lo largo de diferentes artículos periodísticos.

What's being said near "Martha"? Exploring name entities in literature.
Muestra varias herramientas usando como ejemplo el análisis de literatura "rara":
* FeatureLens
* Wordle (Dunning's log likehood)
* POSvis
Necesitaban los Stop-words para analizar el texto.

VAST contest dataset use in education.
Hay un montón de datos de los diferentes VAST contest. Muestran como los usan para dar clases.

VARIAS DE LAS PRESENTACIONES DESTACARON LA NECESIDAD DE PODER IR AL TEXTO ORIGINAL QUE GENERÓ LOS DATOS QUE ESTÁN MOSTRANDO LAS HERRAMIENTAS. Posiblemente pase lo mismo con gráficos sumarizados de ataques.

Vast. Analysis Process & Graph Analytics

Connecting the dots in visual analysis.
Integran notas y flujos de trabajo en el proceso de analisis de los datos. Hacen todo un manejo bastante complicado de los flujos de trabajo (action trails?) del analista. También sugiere a los analistas que miren cosas que ya hicieron. Les preguntaron a 2 analistas sobre si les gustó el enfoque y dijeron que sí.

Capturing and supporting the analysis process.
Otro paper que explica como soportar el proceso del analista. Ejemplo con data set del VAST challenge 2008.

Evaluating visual analytics systems for interactive analysis: Deriving design principles from a case study.
Estudian como un analista usa jigsaw y otras herramientas para hacer tareas de analisis de datos.

A multi-level middle-out cross-zooming approach for large graph analytics.
Muestra una parte del grafo con una "resolución" y otra parte con otra "resolución". Cuando hace zoom-in en algún lado hace zoom-out en otro para mantener + o - constante la cantidad de cosas que muestra. Sirve para grafos de tipo small-worlds (algo parecido a esparsos). La implementación es un bolonqui porque quieren que todo sea interactivo (quién no?).
http://www.pnl.gov/wong

Visual analytics of graphs with multiple connected components.
Share-holder networks == Weighted directed acyclic graph.
Buscan estructuras comunes en estos grafos. Para eso hacen un proceso iterativo donde buscan los componentes.

Tutorial: Exploring design decisions for effective information visualization
Usando datos de las últimas 8 elecciones norteamericanas hicimos un montón de treemaps distintos analizando que se ve en cada uno, que no se ve y buscando la mejor forma de mostrar cosas.

Miércoles 14:
8:30a Keynote: Visual thinking and visual thingking tools
En esta charla Collin Ware estuvo hablando sobre como percibimos las cosas y como esto afecta como nos relacionamos con las herramientas de visualizacion. En particular mostró como se compara una interfase zoomeable con una que abre ventanitas para mostrar detalles y dio algunas formas muy simples de calcular que esfuerzo requiere hacer tareas en ambas interfaces. Usando el mismo ejemplo, también mostró porqué en otro estudio que él hizo convino usar imagenes en vez de video para mostrar movimiento. Esta charla también le da sustento teórico a la necesidad de tener más espacio disponible en el/los monitor(es).

4:15p Models and theories
A nested model for visualization design and validation
* problem
* data/op abstraction
* enc/interact technique
* algorithm
Intenta ordenar cómo saber si una visualización es "buena" o no. Divide en 4 diferentes "aspectos" a una visualización.

Conjunctive visual form.
Hace una especie de query by example pero en vez de poner un ejemplo pone un conjunto para cada dimensión (cross-filtered views, paper del año pasado).

Jueves 15:
Interaction Techniques for Selecting and Manipulating Subgraphs in Network Visualizations
Explica un montón de diferentes formas de operar sobre conjuntos de nodos en un grafo y elegir que conjunto de nodos. Están buenos pero son un quilombo.
Software: Navigator.

ActiviTree: Interactive Visual Exploration of Sequences in Event-Based Data Using Graph Similarity
Buscar patrones en eventos. ¿Puede servir para analizar logs?

“Search, Show Context, Expand on Demand”: Supporting Large Graph Exploration with Degree-of-Interest
Enfoque bottom-up para explorar grafos. Search, show context, expand on demand.
cada nodo tiene un "interes". Con eso, la query que hace el usuario y la estructura del grafo hacen una cuenta y definen el "degree of interest" (DOI) de un nodo. El contexto es el subgrafo conexo que contiene a ese nodo y tiene mayor interés. Para hacer que ande mejor un algoritmo greedy "difunden" el interés en los nodos vecinos. Lo usan para buscar fallos judiciales y como se relacionan.

A Comparison of User-Generated and Automatic Graph Layouts.
Probaron layouts generados a mano por usuarios (usando Surface, de MS) para las tareas que iban a pedir a otros participantes. Después agarraron esos layouts y 3 layouts automáticos más e hicieron que otra gente haga esas cosas. Al final, el mejor fue el force directed layout.

Smooth Graphs for Visual Exploration of Higher-Order State Transitions.
En vez de tomar A-B como "edge" se fijan en secuencias más largas (A-B-C-D, por ejemplo). Usaron esto para analizar el comportamiento de pingüinos.

Harnessing the Web Information Ecosystem with Wiki-based Visualization Dashboards.
Muestra un wiki que sirve para armar dashboards con algunos tipos de visualizaciones.

Viernes
code swarm: A Design Study in Organic Software Visualization
MOstró codeswarm.

Towards Utilizing GPUs in Information Visualization: A Model and Implementation of Image-Space Operations
Mostró un prototipo que usa la GPU para hacer visualizaciones (basado de shaders) y un programa que sirve para implementar los shaders uniendo cajas con flechas.

A Multi-Threading Architecture to Support Interactive Visual Exploration
Arquitectura para hacer visualizaciones:
1 thread de eventos
n threads para n visualizaciones
Los threads de las visualizaciones son interrumpidos cuando los datos que usan para calcular cosas cambian.
Hay un cache de cachos de dibujos y datos intermedios

Protovis: A Graphical Toolkit for Visualization
Toolkit para hacer visualizaciones en JavaScript de los autores de Flare y Prefuse
http://protovis.org

Wipeando discos en el tercer mundo

Tuve que wipear un disco rígido y las herramientas de wipeo que tenía a mano no lo reconocían.
La solución:

# yes > /dev/sda

¿Se les ocurre alguna solución más corta? (wipe-golfing)

Happy hacking,
Aureliano.

Reflexiones sobre las colas

Como les conté en el post anterior, estoy en VisWeek 2009. En esta conferencia hay gente de alrededor de todo el mundo, pero el grueso es de Europa y EEUU. Y hay algunas cosas que me llamaron la atención (positivamente) sobre el comportamiento de la gente por acá.
La primera cosa es que las charlas empiezan y terminan en horario (cronométricamente). El primer día de la conferencia me fui a comer y pensé que la sesión de la tarde iba a empezar algo así como media hora más tarde y en vez de eso empezó en horario y me perdí una charla. Comparado con la laxitud de la Eko, que terminó 2 horas y media después del horario planificado, es mucho mejor. Así que aprendí y empecé a llegar en horario. No como en Argentina que las cosas se van atrasando cada vez más y llegamos a situaciones ridículas donde el horario de entrada a un boliche es las 3 AM.
Pero lo que más me asombró es como se arman colas automáticamente cuando se requiere acceso a un recurso escaso. Es en todos lados. Cuando hay que entrar a una sala grande y la puerta es un cuello de botella. Cuando sacamos comida de las mesas de la conferencia. Esperando el ascensor (!). Si prestás atención, se arman colas en todos lados y todo el mundo las respeta.
¿Será realmente más eficiente hacer las cosas más ordenadamente?,
Aureliano.

Visualizando

El viernes pasado partí a Atlantic City para participar de Visweek, enfocándome especialmente en Vizsec. Como el avión llegó a la mañana del sábado a Filadelfia y la conferencia empezó el domingo, dediqué parte del sábado a caminar por Filadelfia. Y me gustó bastante. Es una ciudad linda, con alma. A pesar de que me mojé porque llovía de a ratos y estaba bastante mareado porque el vuelo desde Washington fue en un avión diminuto que se movía mucho lo disfruté un montón.
A las 13:47 me tomé el tren a Atlantic City, y colapsé por falta de sueño. Alrededor de las 16:30hs llegué a Atlantic City y fui al hotel. El hotel de Atlantic City es una mole gigantesca y el casino es increíblemente grande (no me creen, fíjense).
Y la posta es que no me gusta, pero tiene todas las comodidades que hacen falta para la conferencia, que viene super-interesante. Estoy tomando notas de las charlas a las que voy, así que probablemente las ponga en el blog una vez que las muestre en Core (ellos pagan el viaje así que me parece bien que las vean primero).
Acá estoy empezando a conocer gente y hay un grupo de alemanes que son buena onda y me adoptaron. Estoy contento de que estoy aprendiendo un montón y que estoy conociendo gente super-interesante. Espero saber mucho más sobre visualización cuando termine la conferencia. En particular, estoy buscando herramientas para hacer visualizaciones que sean medianamente razonables (para una definición mía y absolutamente arbitraria de razonable). Por ahora no encontré nada :( y los investigadores con los que hablé todos implementaron sus propias herramientas para hacer visualizaciones.
Por último, cuando termine la conferencia me voy 3 días a Nueva York. ¿Qué me sugieren que haga por allá? Lo que tengo pensado es ir al Central Park, subir al Empire State, cruzar caminando el puente de Brooklin, ir a Wall Street, ir a Broadway, ir a la Quinta Avenida (y quizás hacerme el muerto donde mataron a John Lennon), tomarme el ferry a Staten Island para ver la estatua de la Libertad e ir al Museo de Arte Moderno.
Cuando pueda subo fotos de la conferencia, el viaje, etc.
Happy hacking,
Aureliano.

Mi primer advisory

Encontré un XSS persistente en una aplicación de ejemplo de Jetty. Si quieren ver el advisory, pueden verlo acá.

Jetty es un container de servlets (como Tomcat) que mantiene la Apache foundation (como Tomcat) pero que intenta ser liviano (no como Tomcat).

Happy hacking,
Aureliano.

Destruyendo facebook desde adentro

Update: Puse todos los eventos sobre como me echaron de facebook y se niegan a borrar mis datos en este post.
Update: Mi cuenta de facebook está deshabilitada. Mandé un mail para preguntar porqué la deshabilitaron, porque hasta donde yo sé no violé ninguna de las reglas del servicio. Los voy a mantener al tanto de la respuesta.

Hola a tod@s,
quería contarles que tengo un nuevo proyecto. El mismo se llama "Destruyendo facebook desde adentro" y consiste en ver cómo hacer para que en vez de que haya una sola empresa que maneje la red social de amigos y conocidos cada persona pueda tener sus datos donde quiera e igualmente pueda relacionarse con otra gente. Un poco como el mail, se puede mandar correos a personas que tienen un proveedor de correo distinto del tuyo.
Para eso, hay algunas actividades que pueden hacer:

• sacar la propaganda con greasemonkey (http://userscripts.org/scripts/show/13787)
• taggear mal las fotos
• hacer apps que hagan cagadas
• hacer bots que molesten en facebook (¿convendrá greasemonkey o WATiR para esto?)
• hacer una red social distribuida que use cripto de clave pública para autenticar a las personas (tipo PGP).

Si quieren adherir a mi causa, pueden hacer todo esto (o alguna otra cosa que les parezca conducente) y unirse al grupo en http://www.facebook.com/group.php?gid=141856259260

Happy hacking,
Aureliano.

¡Me atacó el phishing gallego!

Leanlo, ¡no tiene desperdicio!

from Phanida_Roidoung 
reply-to allaccountuser@live.com
to 
date Thu, Aug 6, 2009 at 2:20 PM
subject Dear dc.uba.ar Owner
 
hide details 2:20 PM (34 minutes ago)
 
 
Reply
 
 Follow up message
Dear dc.uba.ar Owner,

We are currently carrying-out a mentaiance
process to your dc.uba.ar account, to
complete this process you must reply to
this email immediately,and enter your User
Name here (******) And Password here(*****)
if you are the rightful owner of this account.

This process we help us to fight against
SPAM MAILS.
Failure to summit your password, will render
your email address n-active from our database.
You can also confirm your email address by
logging into your dc.uba.ar
account at:http://dc.uba.ar

NOTE: You will be send a password reset
messenge in next two (2)
working days after undergoing this process
for security reasons.

Thank you form dc.uba.ar!
THE dc.uba.ar TEAM

En particular, me hace cagar de risa esta parte:

to
complete this process you must reply to
this email immediately,and enter your User
Name here (******) And Password here(*****)
if you are the rightful owner of this account.

Es la versión de mails de phishing del virus gallego.
Happy hacking,
Aureliano

Algunas cosas buenas y malas de python (para mi)

Cosas buenas:

• Duck-typing
  
• Los espacios sirven para marcar bloques de código
• Los bloques de código son elementos de primer orden del lenguaje
  
• Soporte para un montón de cosas (por ejemplo pyCUDA)
• Matches por nombre en expresiones regulares
  

Cosas malas:

• Los objetos no son más que un mejunje de 2 diccionarios (el de la clase y el del objeto, sin orden)
• Un montón de cosas están sacadas de los objetos, pero otras no. Esto lo deja inconsistente y molesto (teniendo que definir un montón de métodos mágicos de la forma __magic__)
  
• Sin sintaxis buena para llamar al método de la clase padre (super, ¿dónde estás?)
• "There is only one way to do it" salvo por las reglas para poner nombres de métodos ni clases. Por ejemplo, no queda claro si debe ser method_name, methodName o methodname (hay de los 3 en las biliotecas estándares)
• No hay forma de definir bloques de código sin nombre (aunque con el agregado del with_statement, están bastante cerca del manejo de bloques de ruby). Los lambdas son una cosa que se queda muy corta.
  
• Sintaxis especiales para demasiadas cosas (ejemplo: list comprehensions, for, while, decorators, etc)
• Falta de separación entre strings y listas de bytes (¿Python 3000 lo arregla?, no sé)
• Metaprogramar es complicado porque no hay bloques sin nombre y hay que definir/ llamar un montón de métodos __mágicos__.
• Separación entre comandos y expresiones.

Happy hacking,
Aureliano.

Tests en rapidito

En rapidito los tests siguen creciendo. Ahora le agregué un test al modelo de la base de datos (que por ahora tiene una sola tabla, pero espero que crezca bastante) y otro a los views y controllers (que también tienen que crecer).
Todo está agregado en el rakefile:

$ rake -T
(in /home/aure/devel/rapidito)
rake db:initial       # Generate the initial pages for the wiki
rake db:migrate       # Migrate the database
rake default          # Run all tests
rake test             # All tests
rake test:functional  # Test controllers and views
rake test:lib         # Library tests
rake test:model       # Model tests

Sigo usando una sqlite3 en memoria para todos los tests (parece que esto paga) y para hacer los tests funcionales usé la gem rack-test como dice en la documentación de sinatra. Es impresionante como sirve esa lib tan chiquitita.
Y los tests siguen creciendo, ya van 651 líneas de código

~/devel/rapidito$ find test -name "*.rb" | xargs wc -l
   26 test/lib/test_lang_hacks.rb
   60 test/lib/elem_stack_test.rb
   35 test/lib/rapidito_data_test.rb
  187 test/lib/rapidito_html_test.rb
   81 test/lib/state_test.rb
   48 test/lib/nodes_test.rb
  110 test/lib/tokenizer_test.rb
   55 test/model/pages_test.rb
   49 test/functional/start_test.rb
  651 total

Happy hacking,
Aureliano

rapidito en github

Hola,
puse un repo de rapidito (mi proyecto de base de datos basado en wikis) en github. Está disponible en http://github.com/aurelianito/rapidito/tree/master.
Si quieren usarlo, solo hay que hacer en el directorio clonado:

rake db:migrate
rake db:initial
rackup

Una vez que está corriendo, te conectás a http://localhost:9292 y tenés todas las instrucciones.
Tiene como requerimientos sinatra, activerecord, markaby y sqlite3 (con su gem).
Voy a ir avanzando este proyecto cuando tenga algo de tiempo. Por ahora es solo un wiki más, pero espero que se transforme en algo distinto. A medida que tenga más cosas agregadas voy a ir avisando en el blog.
Escucho sugerencias, y acepto patches ;).

Happy hacking,
Aureliano.

rake sh en otro directorio

Problema: Quiero ejecutar un comando desde otro directorio en rake (por ejemplo, ejecutar un makefile que está en un subdirectorio).
Solución: Agrego al rakefile la posibilidad de ejecutar comandos en otro directorio. Para eso, al principio de mi rakefile puse:

require 'fileutils'

def sh_in_dir( dirname, *args, &block )
  old_path = pwd
  FileUtils.chdir( dirname )
  sh( *args, &block )
  FileUtils.chdir( old_path )
end

Happy hacking,
Aureliano.

Firefox remoto y local

Problema: Tengo un firefox corriendo en X11 y quiero correr otro firefox remotamente por X11 en otro host (usando el mismo display). Si lo ejecuto directamente, haciendo ssh -X -n host firefox en vez de ejecutar el Firefox en la otra máquina, abre otra ventana del firefox que ya tengo corriendo.
Solución: Usando la opción -no-remote evito que el firefox busque ventanas de firefox abiertas para abrir una ventana nueva y se ejecuta remotamente. La línea de comando entera es: ssh -X -n host firefox -no-remote.

Gracias Pedro Varangot por contarme del parámetro -no-remote

Happy hacking,
Aureliano.

Logo versión 2

Esta versión del logo de rapidito se viene con texto y fondo. Y me parece que se "mueve" un poco más. De a poco voy aprendiendo a usar el inkscape.

Logo para rapidito

Estoy pensando en un logo para la base de datos/wiki que estoy haciendo. ¿Qué les parece este? La idea es ponerlo arriba a la izquierda en todas las páginas y como ícono en la barra de navegación del browser.

Patch en Regexp para poder usarlas como clave en un Hash

Siguiendo mi proyecto de hacer mi wiki en Ruby, encontré un comportamiento muy raro.
Generé un hash (que se llama @rules) que no tiene un elemento que tiene. O sea, @rules[@rules.keys[2]] da nil, pero @rules.values[2] devuelve el objeto asociado a la clave @rules.keys[2]. Como este hash tiene como claves un montón de expresiones regulares, me imaginé que había un problema con el hash y el eql? de Regexp, así que los implementé de nuevo y monkeypatchié.
Este es el código:

class Regexp
 alias_method :old_rapidito_inspect, :inspect

 def inspect
   @inspect = old_rapidito_inspect if @inspect.nil?
   @inspect
 end

 def eql?( other )
   false if other.class != Regexp
   self.inspect == other.inspect
 end

 alias_method :"==", :eql?

 def hash
   self.inspect.hash
 end
end

Esta corrección me anduvo con la siguiente versión de ruby:

$ ruby --version
ruby 1.8.7 (2008-08-11 patchlevel 72) [i486-linux]

Espero que les sirva.
Happy hacking,
Aureliano.

Upcase con acentos

En ruby no se calculan los cambios minúscula mayúscula para las letras acentuadas. Por ejemplo:

irb(main):002:0> puts "áa".upcase
áA
=> nil

Para que ande un poco mejor (y tome las letras acentuadas de un montón de lenguajes), encontré un hack que en 10 líneas de código hace que puedan pasarse a mínusculas y mayúsculas los caracteres acentuados. Usando que todas las letras minúsculas y mayúsculas acentuadas están todas juntas, armé un par de gsubs que resuelven el problema.

class String
  alias_method :old_rapidito_upcase, :upcase
  def upcase
    self.gsub( /\303[\240-\277]/ ) do
      |match|
      match[0].chr + (match[1] - 040).chr
    end.old_rapidito_upcase
  end
  
  alias_method :old_rapidito_downcase, :downcase
  def downcase
    self.gsub( /\303[\200-\237]/ ) do
      |match|
      match[0].chr + (match[1] + 040).chr
    end.old_rapidito_downcase
  end
end

Lo que hago acá es reemplazar las funciones upcase y downcase para que manejen los acentos, sumando o restando 32 (40 en octal) al segundo byte. Pongo este código en lang_hacks.rb y sale todo con fritas. Mirando el irb

irb(main):001:0> require 'lang_hacks'
=> true
irb(main):002:0> "aÁ".upcase
=> "A\303\201"
irb(main):003:0> puts "aÁ".upcase
AÁ
=> nil

Espero que les sirva.
Happy hacking,
Aureliano.

Rap del dengue sojero

Entra enfermo de dengue
Mosquito pica enfermo
Sapo se come mosquito
¡No hay dengue!

Alfredo planta soja
Alfredo fumiga veneno
Veneno mata sapito
Sapo muerto no come mosquito
¡Hay soja!
¡Hay veneno!
¡No hay sapo!
¡Hay dengue!
¡Hay mosquito!

Hormiga atómica fumiga mosquito
Sapo vivo se caga de hambre
Año que viene
¡Se muere!
¡No hay sapo!
¡Hay dengue!
¡Hay malaria!
¡Hay peste!
¡Hay mosquito!

Nonsanto reparte los sobres
Al periodismo in-the-pendiente
¡Hay sobre!
¡No hay noticia!
¡Hay soja!
¡Hay veneno!
¡No hay sapo!
¡Hay dengue!
¡Hay mosquito!

Nonsanto no garpa bloguero
Bloguero publica noticia
¡Nonsanto se cae de culo!
¡Cristina prohibe la soja!
¡No hay sobre!
¡Hay sapo!
¡No hay dengue!
¡No hay mosquito!

Vía: artepolitica.com

Autofit guest solo anda si abrís la consola después de loguearte

Comprobado en Vmware Server 2.0.1.
Host: KUbuntu 9.0.4. 64 bits.
Guest: KUbuntu 9.0.4. 32 bits.

¿Estoy haciendo algo mal?
Aureliano.

Más rapidito

Como les estuve contando, sigo escribiendo mi wiki. Ya parsea un subconjunto interesante del lenguaje definido por trac.
Siguiendo la tradición, les cuento como está avanzando el tokenizer. Al tokenizer lo simplifiqué para que devuelva la expresión regular que matcheo junto con el match (en vez del "tipo"). Esto hizo que la interfase para definir las reglas para tokenizar sea más simple. Si no hay ninguna regla que matchee sigue devolviendo ["string", :text].
Sin más, acá el código:

module Rapidito
  class Tokenizer
  
    def initialize( *delimiters )
      @delimiter_list = delimiters +  [/\z/]
      @match_cache = nil
    end
    
    def source
      valid_cache? ? @match_cache[0].to_s + @source : @source
    end
    
    def source=(s)
      @match_cache = nil
      @source = s
    end
    
    def has_next?
      !@source.empty? || valid_cache?
    end
    
    def valid_cache?
      (!@match_cache.nil?) && (@match_cache[0].to_s.length > 0)
    end
    
    def next_match
      @delimiter_list.map {|regex| [regex.match(@source),regex]}.reject {|p| p[0].nil?}.inject do
        |better,new|
        better_pos = better[0].pre_match.length
        new_pos = new[0].pre_match.length
        
        if better_pos < new_pos
          better
        elsif new_pos < better_pos
          new
        elsif better[0].to_s.length > new[0].to_s.length
          better
        else
          new
        end
      end
    end
    
    def next_token
      if @match_cache #cached delimiter
        rv = @match_cache
        @match_cache = nil
        return rv
      end
      
      match = next_match
      p = match[0].pre_match.length
      @source = @source[p + match[0].to_s.length, @source.length]
      
      if p == 0 #delimiter
        match
      else #text
        @match_cache = match
        [match[0].pre_match, :text]
      end
    end
    
    def all_tokens
      tokens = []
      while has_next?
        tokens << next_token
      end
      tokens
    end
  end
end

Y si miran los tests de unidad, van a ver que también quedaron más lindos:

require 'test/unit'
require 'rapidito/tokenizer'

include Rapidito

class TokenizerTest < Test::Unit::TestCase
  
  def test_no_token
    tok = Tokenizer.new
    tok.source = "aaaa"
    assert_equal true, tok.has_next?
    assert_equal ["aaaa", :text], tok.next_token
    assert_equal false, tok.has_next?
  end
  
  def assert_all_tokens( expected, tokenizer )
    assert_equal expected, 
      tokenizer.all_tokens.map { |token, kind| [token.to_s, kind] }
  end
  
  def test_two_delimiters
    tok = Tokenizer.new( 
      /\|/, /;;/ 
    )
    
    tok.source = "aa|bbb;;;;cccc"
    assert_all_tokens \
      [ ["aa", :text], ["|", /\|/], ["bbb", :text], 
        [";;", /;;/], [";;", /;;/], ["cccc", :text] ], 
      tok
    
    tok.source = "aa;;bbb||cccc"
    assert_all_tokens \
      [ ["aa", :text], [";;", /;;/], ["bbb", :text], 
        ["|", /\|/], ["|", /\|/], ["cccc", :text] ], 
      tok
  end
  
  def test_choose_longest_match
    tok = Tokenizer.new( 
      /aa/, /aaa/
    )
    tok.source = "aaaa"
    assert_all_tokens [ ["aaa", /aaa/], ["a", :text ] ], tok
  end
  
  def test_reset_precache
    tok = Tokenizer.new( 
      /\|/, /,/
    )
    tok.source = "original start|original end"
    tok.next_token
    tok.source = "new start,new end"
    assert_equal ["new start", :text], tok.next_token
  end
  
  def test_almost_finished
    tok = Tokenizer.new( /!/ )
    tok.source = "bang!"
    tok.next_token
    assert_equal true, tok.has_next?
    tok.next_token
    assert_equal false, tok.has_next?
  end
  
  def test_carriage_return_ending
    tok = Tokenizer.new( /!/ )
    tok.source = "bang!\n"
    tok.next_token
    assert_equal true, tok.has_next?
    tok.next_token
    assert_equal true, tok.has_next?
    assert_equal "\n", tok.next_token[0].to_s
    assert_equal false, tok.has_next?
  end
  
  def test_transparent_caching
    tok = Tokenizer.new( /!/ )
    tok.source = "bang!pum"
    tok.next_token
    
    assert_equal "!pum", tok.source
  end
  
  def test_match_klass
    tok = Tokenizer.new( /!/ )
    tok.source = "!bang!pum"
    
    assert_equal \
      [MatchData, String, MatchData, String], 
      tok.all_tokens.map { |tok, kind| tok.class }
  end
end

Happy hacking,
Aureliano.

Bouncer versión 2

Hice una nueva versión del bouncer que permite bouncear a varios targets desde un mismo host:

#!/usr/bin/env ruby

# == Synopsis
#
# bouncer.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 Bouncer
 def self.for_host( source_ip, start_port, targets )
  rules = {}
  targets.each_with_index do
   |target, index|
   rules[ start_port + index ] = target
  end
  self.new( source_ip, rules )
 end
 def initialize( source_ip, port_target_map )
  @port_target_map = port_target_map
  @source_ip = source_ip

  @servers = @port_target_map.keys.map do
    |port|
    ss = TCPServer.new( "", port )
    ss.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
    ss
  end
    
  @descriptors = @servers.clone
  @next_step = {}
 end

 def handle_new_connection( ss )
  incoming = ss.accept
  if incoming.peeraddr[3] == @source_ip
   begin
    outgoing = TCPSocket.new( *@port_target_map[incoming.addr[1]] )
    @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 @servers.include? sock then
     handle_new_connection( sock )
    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'
   RDoc::usage
   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

 Bouncer.new(ip, port => [target[0], target[1].to_i]).run
end

Mousewheel para arriba en vmware

Encontré como hacer para que ande bien la ruedita del mouse adentro de un Guest de VMWare con Kubuntu 9.04. Hay que instalar el paquete xserver-xorg-input-vmmouse.
Happy hacking,
Aureliano.

Cambiando de resolución en X

El comando xrandr sirve, entre otras cosas para cambiar la resolución de X desde un shell. Primero listo las resoluciones disponibles:

$ xrandr
Screen 0: minimum 320 x 200, current 1280 x 1024, maximum 1280 x 1280
VGA connected 1280x1024+0+0 (normal left inverted right x axis y axis) 338mm x 270mm
   1280x1024      60.0*+   75.0     60.0*
   1152x864       75.0
   1024x768       75.0     60.0
   800x600        75.0     60.3
   640x480        75.0     59.9
   720x400        70.1

y puedo elegir la que quiera con el parámetro -s. Por ejemplo:

$ xrandr -s 800x600

Happy hacking,
Aureliano

Pequeñas delicias de las expresiones regulares

Como les conté acá y acá, estoy escribiendo un tokenizador para un wiki que estoy programando. Y hoy me encontré con una cosa muy extraña de las expresiones regulares.
En ruby la función match sirve para buscar el primer match de una regex dentro de un string. Por ejemplo (usando el irb):

irb(main):001:0> m = /a/.match "babab"
=> #<MatchData "a">
irb(main):002:0> m.pre_match
=> "b"
irb(main):003:0> m[0]
=> "a"

En particular, el pre_match es lo que está antes del match en el string. También según había entendido (mal) /\Z/ matchea con el final del string. Por ejemplo:

irb(main):004:0> m = /\Z/.match "hola"
=> #<MatchData "">
irb(main):005:0> m.pre_match
=> "hola"

Pero, /\Z/ tiene un comportamiento muy extraño, aunque documentado, cuando el último caracter antes del final es un \n. Lo que pasa es que el pre_match queda ¡sin el \n del final!. Lo muestro en el irb:

irb(main):006:0> m = /\Z/.match "\n"
=> #<MatchData "">
irb(main):007:0> m.pre_match
=> ""

Para que no se manduque el \n, hay que usar /\z/ (¡en minúscula!):

irb(main):008:0> m = /\z/.match "\n"
=> #<MatchData "">
irb(main):009:0> m.pre_match
=> "\n"

Por lo tanto tuve que tocar el tokenizer, ahora la función de initialize quedó así (miren el cambio de la "Z" a "z"):

    def initialize( delimiters )
      @delimiter_list = [[/\z/, :finish]] + 
        delimiters.to_a.map { |k,arr| arr.map { |re| [re, k] } }.inject([]) { |ac,ps| ac + ps }
      @match_cache = nil
    end

Y el test que captura el problema que genera usar \Z en vez de \z quedó así:

  def test_carriage_return_ending
    tok = Tokenizer.new( :a_kind => [/!/] )
    tok.source = "bang!\n"
    tok.next_token
    assert_equal true, tok.has_next?
    tok.next_token
    assert_equal true, tok.has_next?
    assert_equal "\n", tok.next_token[0].to_s
    assert_equal false, tok.has_next?
  end

Happy hacking,
Aureliano.

Tokenizer de rapidito, segunda versión

Como les conté hace un par de posts, estoy haciendo un wiki y blogueando sobre el tokenizer
Hoy les cuento de la segunda versión del tokenizer. A esta versión (que no es compatible con la anterior) le agregué la posibilidad de asociar un tipo (kind) a cada regexp que define un token. Por lo tanto, el método next_match ahora devuelve un par [match, kind]. Los matches de texto común (no delimitadores) tienen kind :text. Los matches de los delimitadores vienen con la MatchData entera, para poder usarla si interesan partes del match a la hora de procesar el token. También dejé de usar =~ para matchear regexps, ya que el
Me quedaron un par de cosas con dudas después de implementar esto.

1. ¿Se puede hacer en ruby que busque un match de una regexp en un string a partir de una posición? Hacer una regexp del tipo /.{34,}(regex de verdad)/ no vale.
2. ¿Puedo forzar a la unión de expresiones regulares a buscar el match más largo (en vez del primero que matchee)?

A pesar de las dudas, igual tengo una versión que creo que es significativamente mejor que la versión anterior.
Así que como la otra vez dejo el código:

module Rapidito
  class Tokenizer
  
    attr_reader :source
  
    def initialize( delimiters )
      @delimiter_list = [[/\Z/, :finish]] + 
        delimiters.to_a.map { |k,arr| arr.map { |re| [re, k] } }.inject([]) { |ac,ps| ac + ps }
      @match_cache = nil
    end
    
    def source=(s)
      @match_cache = nil
      @source = s
    end
    
    def has_next?
      !@source.empty? || valid_cache?
    end
    
    def valid_cache?
      (!@match_cache.nil?) && (@match_cache[0].to_s.length > 0)
    end
    
    def next_match
      @delimiter_list.map {|p| [p[0].match(@source), p[1]]}.reject {|p| p[0].nil?}.inject do
        |better,new|
        better_pos = better[0].pre_match.length
        new_pos = new[0].pre_match.length
        
        if better_pos < new_pos
          better
        elsif new_pos < better_pos
          new
        elsif better[0].to_s.length > new[0].to_s.length
          better
        else
          new
        end
      end
    end
    
    def next_token
      if @match_cache #cached delimiter
        rv = @match_cache
        @match_cache = nil
        return rv
      end
      
      match = next_match
      p = match[0].pre_match.length
      @source = @source[p + match[0].to_s.length, @source.length]
      
      if p == 0 #delimiter
        [match[0].to_s, match[1]]
      else #text
        @match_cache = match
        [match[0].pre_match, :text]
      end
    end
    
    def all_tokens
      tokens = []
      while has_next?
        tokens << next_token
      end
      tokens
    end
  end
end

Y los tests de unidad:

require 'test/unit'
require 'rapidito/tokenizer'

include Rapidito

class TokenizerTest < Test::Unit::TestCase
  
  def test_no_token
    tok = Tokenizer.new( {} )
    tok.source = "aaaa"
    assert_equal true, tok.has_next?
    assert_equal ["aaaa", :text], tok.next_token
    assert_equal false, tok.has_next?
  end
  
  def assert_all_tokens( expected, tokenizer )
    assert_equal expected, 
      tokenizer.all_tokens.map { |token, kind| [token.to_s, kind] }
  end
  
  def test_two_delimiters
    tok = Tokenizer.new( 
      :a_kind => [/\|/, /;;/] 
    )
    
    tok.source = "aa|bbb;;;;cccc"
    assert_all_tokens \
      [ ["aa", :text], ["|", :a_kind], ["bbb", :text], 
        [";;", :a_kind], [";;", :a_kind], ["cccc", :text] ], 
      tok
    
    tok.source = "aa;;bbb||cccc"
    assert_all_tokens \
      [ ["aa", :text], [";;", :a_kind], ["bbb", :text], 
        ["|", :a_kind], ["|", :a_kind], ["cccc", :text] ], 
      tok
  end
  
  def test_choose_longest_match
    tok = Tokenizer.new( 
      :a_kind => [/aa/, /aaa/] 
    )
    tok.source = "aaaa"
    assert_equal [ ["aaa", :a_kind], ["a", :text ] ], tok.all_tokens
  end
  
  def test_reset_precache
    tok = Tokenizer.new( 
      :a_kind => [/\|/, /,/]
    )
    tok.source = "original start|original end"
    tok.next_token
    tok.source = "new start,new end"
    assert_equal ["new start", :text], tok.next_token
  end
  
  def test_almost_finished
    tok = Tokenizer.new( :a_kind => [/!/] )
    tok.source = "bang!"
    tok.next_token
    assert_equal true, tok.has_next?
    tok.next_token
    assert_equal false, tok.has_next?
  end
end

Happy hacking,
Aureliano.

Syntax highlighting de Ruby en mi blog

Tomando como base lo que dice en este post, hice un script en ruby que genera html con clases que se pueden poner coloritos con css:

#!/usr/bin/env ruby

require 'rubygems'
require 'syntax/convertors/html'

class Syntax::Convertors::HTML
  def convert( text, klass="" )
    html = "<pre class=\"#{klass}\">"
    regions = []
    @tokenizer.tokenize( text ) do |tok|
      value = html_escape(tok)
      case tok.instruction
        when :region_close then
          regions.pop
          html << "</span>"
        when :region_open then
          regions.push tok.group
          html << "<span class=\"#{tok.group}\">#{value}"
        else
          if tok.group == ( regions.last || :normal )
            html << value
          else
            html << "<span class=\"#{tok.group}\">#{value}</span>"
          end
      end
    end
    html << "</span>" while regions.pop
    html << "</pre>" 
    html
  end
end

convertor = Syntax::Convertors::HTML.for_syntax "ruby"
puts convertor.convert( $stdin.read, "ruby"  )

En el script monkeypatchié un toque para que agregue la clase "ruby" al tag pre que engloba todo el código y aparte estoy usando estos estilos:

<style>
pre.ruby {
      background-color: #ffffcc;
      color: #000000;
      padding: 10px;
      font-size: 1.1em;
      overflow: auto;
      margin: 4px 0px;
      width: 95%;
      border: thin dashed;
}
.ruby .normal {}
.ruby .comment { color: #005; font-style: italic; }
.ruby .keyword { color: #A00; font-weight: bold; }
.ruby .method { color: #077; }
.ruby .class { color: #074; }
.ruby .module { color: #050; }
.ruby .punct { color: #447; font-weight: bold; }
.ruby .symbol { color: #099; }
.ruby .string { color: #944; }
.ruby .char { color: #F07; }
.ruby .ident { color: #004; }
.ruby .constant { color: #07F; }
.ruby .regex { color: #B66; }
.ruby .number { color: #D55; }
.ruby .attribute { color: #377; }
.ruby .global { color: #3B7; }
.ruby .expr { color: #227; }
</style>

Una cosa más, si estás viendo este post en otro lugar que no sea aurelianito.blogspot.com no vas a ver el resaltado de sintaxis (ya que no va a tener los estilos).

Hasta la próxima,
Aureliano

Tokenizer de rapidito

Después de mirar un rato el estado de las bibliotecas para hacer wikis en Ruby, y descubrir que ninguna me servía, Decidí que tenía que poner cartas en el asunto y hacer la mía. Mi idea es implementar el markup de Trac, haciéndolo extensible, y agregarle un par de cositas que por ahora son un secreto :-p.

Lo importante del asunto es que puse manos en el asunto. Al final, después de un intento fallido de hackear mi camino al andar, decidí que lo mejor es armar un tokenizer y un parser que use esos tokens para generar el árbol del que extraeré el HTML.

Así que me puse a programar. Como no encontré ningún tokenizer en ruby, programé uno. El tokenizer se contruye con un montón de expresiones regulares que definen cada delimitador. Después se le setea una fuente de caracteres (un string) y separa el string en los delimitadores de arriba (que se devuelven como símbolos) y cadenas que no matchean con ninguno de los delimitadores (que devuelve como strings).

Bueno, basta de cháchara, acá tá el código:

module Rapidito
  class Tokenizer
  
    def initialize( *delimiters )
      @regexp = Regexp.union( *delimiters  + [/$/] )
    end
    
    attr_accessor :source
    
    def has_next?
      ! @source.empty?
    end
    
    def next_token
      p = (@source =~ @regexp)
      if p == 0 #delimiter
        token = nil
        @source.sub!( @regexp ) { |match| token=match.to_sym; "" }
        token
      else #text
        token = @source[0,p]
        @source = @source[p,@source.length]
        token
      end
    end
    
    def all_tokens
      tokens = []
      while has_next?
        tokens << next_token
      end
      tokens
    end
    
  end
end

Y, acá abajo la única documentación que hice hasta ahora, o sea los tests de unidad:

require 'test/unit'
require 'rapidito/tokenizer'

include Rapidito

class TokenizerTest < Test::Unit::TestCase
  
  def test_no_token
    tok = Tokenizer.new
    tok.source = "aaaa"
    assert_equal true, tok.has_next?
    assert_equal "aaaa", tok.next_token
    assert_equal false, tok.has_next?
  end
  
  def test_two_delimiters
    tok = Tokenizer.new( /\|/, /;;/ )
    tok.source = "aa|bbb;;;;cccc"
    assert_equal [ "aa", :"|", "bbb", :";;", :";;", "cccc" ], tok.all_tokens
    
    tok.source = "aa;;bbb||cccc"
    assert_equal [ "aa", :";;", "bbb", :"|", :"|", "cccc" ], tok.all_tokens
  end
  
  def test_choose_first_match
    tok = Tokenizer.new( /aa/, /aaa/ )
    tok.source = "aaa"
    assert_equal [ :aa, "a" ], tok.all_tokens
  end
  
end

Happy hacking,
Aureliano.

PD: ¿Prefieren que ponga el código con syntax highlighting?

Quine en ruby

En el ruby quiz pusieron como problema de la semana hacer un quine en ruby. Un quine es un programa que genera como salida el código fuente del mismo (ver wikipedia).

Así que puse manos a la obra. Agarre el último quine en C de la página de wikipedia:

main() { char *s="main() { char *s=%c%s%c; printf(s,34,s,34); }"; printf(s,34,s,34); }

Y lo traduje a ruby:

s="s=%c%s%c;printf(s,34,s,34)";printf(s,34,s,34)

En ruby no hace falta tener main, porque todo lo que agarra el intérprete lo ejecuta y tampoco hay que declarar variables, así que quedó de 48 caracteres.

Y después hice uno que hace que tenga un ENTER al final, quedando más lindo cuando lo corrés de la consola:

s="s=%c%s%c;printf(s,34,s,34,13,10)%c%c";printf(s,34,s,34,13,10)

Fueron 10 minutos divertidos.

Happy hacking,
Aureliano.

99 botellas de cerveza

Yo no soy un fan de Perl, pero a veces aparecen cosas increíbles. Por ejemplo, este es un programa válido en perl:

    ''=~(        '(?{'        .('`'        |'%')        .('['        ^'-')
    .('`'        |'!')        .('`'        |',')        .'"'.        '\\$'
    .'=='        .('['        ^'+')        .('`'        |'/')        .('['
    ^'+')        .'||'        .(';'        &'=')        .(';'        &'=')
    .';-'        .'-'.        '\\$'        .'=;'        .('['        ^'(')
    .('['        ^'.')        .('`'        |'"')        .('!'        ^'+')
   .'_\\{'      .'(\\$'      .';=('.      '\\$=|'      ."\|".(      '`'^'.'
  ).(('`')|    '/').').'    .'\\"'.+(    '{'^'[').    ('`'|'"')    .('`'|'/'
 ).('['^'/')  .('['^'/').  ('`'|',').(  '`'|('%')).  '\\".\\"'.(  '['^('(')).
 '\\"'.('['^  '#').'!!--'  .'\\$=.\\"'  .('{'^'[').  ('`'|'/').(  '`'|"\&").(
 '{'^"\[").(  '`'|"\"").(  '`'|"\%").(  '`'|"\%").(  '['^(')')).  '\\").\\"'.
 ('{'^'[').(  '`'|"\/").(  '`'|"\.").(  '{'^"\[").(  '['^"\/").(  '`'|"\(").(
 '`'|"\%").(  '{'^"\[").(  '['^"\,").(  '`'|"\!").(  '`'|"\,").(  '`'|(',')).
 '\\"\\}'.+(  '['^"\+").(  '['^"\)").(  '`'|"\)").(  '`'|"\.").(  '['^('/')).
 '+_,\\",'.(  '{'^('[')).  ('\\$;!').(  '!'^"\+").(  '{'^"\/").(  '`'|"\!").(
 '`'|"\+").(  '`'|"\%").(  '{'^"\[").(  '`'|"\/").(  '`'|"\.").(  '`'|"\%").(
 '{'^"\[").(  '`'|"\$").(  '`'|"\/").(  '['^"\,").(  '`'|('.')).  ','.(('{')^
 '[').("\["^  '+').("\`"|  '!').("\["^  '(').("\["^  '(').("\{"^  '[').("\`"|
 ')').("\["^  '/').("\{"^  '[').("\`"|  '!').("\["^  ')').("\`"|  '/').("\["^
 '.').("\`"|  '.').("\`"|  '$')."\,".(  '!'^('+')).  '\\",_,\\"'  .'!'.("\!"^
 '+').("\!"^  '+').'\\"'.  ('['^',').(  '`'|"\(").(  '`'|"\)").(  '`'|"\,").(
 '`'|('%')).  '++\\$="})'  );$:=('.')^  '~';$~='@'|  '(';$^=')'^  '[';$/='`';

Y genera la letra de la canción 99 bottles of beer.

Para ver la explicación sobre como hicieron esto, mirá acá.

Happy hacking,
Aureliano.

PD: ¿Se podrá hacer algo así en ruby?

Referencia de administradores de consorcio

En el consorcio donde vivo estamos cambiando de administración. Para ello se recibieron propuestas escritas de un montón de administradoras. Después de ser analizadas, elegimos 4 para entrevistar. De esas 4, si sale todo bien, deberíamos elegir a la brevedad cuál de ellas será nuestra próxima administración.
Por lo tanto, quería pedirles que me cuenten si tienen referencias (tanto buenas como malas) de estas administraciones. Las mismas son:

• Administración Becherini. TE: 4983-8206
• Administración Farfán. Página web: http://www.admfarfandelnido.com.ar
• Administración Fernandez. Página web: http://www.admfernandez.com.ar
• Administración Schmahl. TE: 4952-1323

Muchas gracias,
Aureliano.

Pinky y Cerebro

Gracias Pedro Varangot por la idea.

Y para los que no conocen la versión original:

YMCA

Bouncer básico en ruby

Estuve programando un bouncer, usando como base el load balancer que hice el año pasado. Un bouncer es un programa que poner un server TCP en un puerto y cada vez que recibe una conexión abre una conexión a otro lado y las "ata", haciendo que el server al que se conecta le conteste al cliente que se conecta a él.
En mi caso lo programé para tener una salida controlada del entorno de máquinas virtuales que estoy armando para tener más ordenadas las cosas en el trabajo.
Por si les interesa, acá abajo pongo el código completo.

#!/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'
   RDoc::usage
   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

Charla de erlang

El viernes pasado di una charla sobre erlang en el trabajo. En la misma, muestro como escribir programas secuenciales en erlang y después un poco de programación distribuida. Para presentar usé esta presentación (ojo, tenés que abrirla con OpenOffice). Abajo pongo lo que planifiqué dar (que es muy parecido a lo que di).

Programación secuencial

"Variables" inmutables

1> X = 1.
1
2> X = 2.
** exception error: no match of right hand side value 2
3> X = 1.
1

Atomos

4> aaaa.
aaaa
5> bbbb.
bbbb
6> Y = bbbb.
bbbb
7> Y.
bbbb
8> Y = aaaa.
** exception error: no match of right hand side value aaaa

Tuplas y listas (y pattern matching)

9> L = [1, 2, 3]
.
[1,2,3]
10> L2 = [-1, 0 | L]
.
[-1,0,1,2,3]
11> [H1, H2, H3 | _ ] = L2
.
[-1,0,1,2,3]
12> H1.
-1
13> H2.
0
14> H3.
1

15> Yo = {person, {fname, "Aureliano"}, {lname, "Calvo"}}.
{person,{fname,"Aureliano"},{lname,"Calvo"}}
16> Yo.
{person,{fname,"Aureliano"},{lname,"Calvo"}}
17> {person, {fname, Name},_} = Yo.
{person,{fname,"Aureliano"},{lname,"Calvo"}}
18> Name.
"Aureliano"

Expresiones case

34> X = 1. EL = []. L = [1,2,3].
1
35> []
36> [1,2,3]

38> case X of [] -> empty_list; [H|T] -> {head, H}; _ -> not_a_list end.
not_a_list
39> case EL of [] -> empty_list; [H|T] -> {head, H}; _ -> not_a_list end.
empty_list
40> case L of [] -> empty_list; [H|T] -> {head, H}; _ -> not_a_list end.
{head,1}

Funciones

En fruit.erl,

price( pear ) -> 4.0;
price( banana ) -> 3.0;
price( apple ) -> 6.0;
price( orange ) -> 2.0;

En consola,

13> fruit:price( pear ).
4.0
14> fruit:price( banana ).
3.0

Usando pattern matching un toque más en serio: En fruit.erl,

price( [] ) -> 0.0;
price( [{Kilos, Fruit}|Rest] ) -> Kilos * price( Fruit ) + price( Rest ).

En la consola,

15> fruit:price( [] ).
0.0
18> fruit:price( [{2.5, banana}, {1.5, apple}] ).
16.5

Pero para que use mejor el espacio (y no se acabe el stack), lo escribo tail recursive (acá explico que el stack sino se va a la mierda):

price2( L ) -> price2( L, 0.0 ).

price2( [], Acum ) -> Acum;
price2( [{Kilos, Fruit}|Rest], Acum ) -> price2( Rest, Kilos * price( Fruit ) + Acum ).

Programación distribuida

spawn, send y receive

spawn lanza un proceso nuevo de erlang, send (!) manda un mensaje a un proceso, y receive lo recibe.

Hago el fruit_shop.erl.

42> c( fruit_shop).
{ok,fruit_shop}
43> FS = fruit_shop:spawn_shop( [ {banana, 15.0}, {pear, 10.0}, {apple, 10.0}], [ {banana, 3.0}, {pear, 4.0}, {apple, 6.0} ] ).

Y lo uso:

(a@tango)3> fruit_shop:stock(FS).
[{banana,15.0},{pear,10.0},{apple,10.0}]
(a@tango)8> fruit_shop:buy(FS, [{2.0, apple}]).
{purchased,12.0}
(a@tango)10> fruit_shop:stock(FS).
[{apple,8.0},[{banana,15.0},{pear,10.0}]]

Por último, lanzar procesos en otros nodos es casi lo mismo: (spawn con un parámetro más, todo el resto igual).

Pongo 2 consolas de erlang:

>erl -sname a -setcookie oreo
>erl -sname b -setcookie oreo

En la primera lanzo la frutería sobre el segundo nodo:

(a@tango)7> FS = fruit_shop:spawn_shop( 'b@tango', [ {banana, 15.0}, {pear, 10.0
}, {apple, 10.0}], [ {banana, 3.0}, {pear, 4.0}, {apple, 6.0} ] ).

Hago lo mismo que antes:

(a@tango)3> fruit_shop:stock(FS).
[{banana,15.0},{pear,10.0},{apple,10.0}]
(a@tango)8> fruit_shop:buy(FS, [{2.0, apple}]).
{purchased,12.0}
(a@tango)10> fruit_shop:stock(FS).
[{apple,8.0},[{banana,15.0},{pear,10.0}]]

Mato la segunda consola y ahora las operaciones dan timeout:

(a@tango)11> fruit_shop:stock(FS).
timeout
(a@tango)12> fruit_shop:buy(FS, [{2.0, apple}]).
timeout

Pintada

Vía volandovengo

como sacar numeros del 0 al 9 con los digitos 4 4 4 4 (parte 3)

Sigo jugando con los 4s y ahora quería contarles una curiosidad. Si saco la potenciación de las operaciones posibles, se pueden armar los mismos números que antes:

0 == (4 / (4 * (4 * 4)))
1 == (4 / (4 / (4 / 4)))
2 == (4 / ((4 + 4) / 4))
3 == ((4 + (4 + 4)) / 4)
4 == (4 - (4 / (4 * 4)))
5 == ((4 + (4 * 4)) / 4)
6 == (4 + ((4 + 4) / 4))
7 == (4 + (4 - (4 / 4)))
8 == (4 - (4 - (4 + 4)))
9 == (4 + (4 + (4 / 4)))
10 ==
11 ==
12 == (4 * (4 - (4 / 4)))
13 ==
14 ==
15 == ((4 * 4) - (4 / 4))
16 == (4 * (4 / (4 / 4)))
17 == ((4 / 4) + (4 * 4))
18 ==
19 ==
20 == (4 * (4 + (4 / 4)))
21 ==
22 ==
23 ==
24 == (4 + (4 + (4 * 4)))
25 ==
26 ==
27 ==
28 == ((4 * (4 + 4)) - 4)
29 ==
30 ==
31 ==
32 == ((4 * 4) + (4 * 4))
33 ==
34 ==
35 ==
36 == (4 + (4 * (4 + 4)))
37 ==
38 ==
39 ==
40 ==
41 ==
42 ==
43 ==
44 ==
45 ==
46 ==
47 ==
48 == (4 * (4 + (4 + 4)))
49 ==
50 ==

¿Loco no? Para probarlo, saquen ** de la lista de posibles operadores y corran el script de la entrada anterior del blog.

Happy hacking,
Aureliano.

como sacar numeros del 0 al 9 con los digitos 4 4 4 4 (parte 2)

En la entrada anterior del blog puse el desafío de calcular los números del 1 al 50 haciendo operaciones aritméticas sobre 4 4s, y como generarlos para los números que van del 0 al 9. Pero me quedé con la duda de si es posible hacerlo para todos los números menores a 50, así que escribí un programita en ruby que calcula todas las posibles evaluaciones usando los operadores +, -, *, / y **. Lo único, hay que tener en cuenta que la división es entera, por lo que hay algunos resultados poco intuitivos.

Al final, el primer número imposible es el 10 (por eso no encontraba como armarlo :D). Acá les muestro la salida del programa:

0 == (4 / (4 ** (4 ** 4)))
1 == (4 ** (4 / (4 ** 4)))
2 == (4 / ((4 + 4) / 4))
3 == (4 - (4 ** (4 - 4)))
4 == (4 ** (4 ** (4 - 4)))
5 == (4 + (4 ** (4 - 4)))
6 == (4 + ((4 + 4) / 4))
7 == (4 + (4 - (4 / 4)))
8 == (4 - (4 - (4 + 4)))
9 == (4 + (4 + (4 / 4)))
10 ==
11 ==
12 == (4 * (4 - (4 / 4)))
13 ==
14 ==
15 == ((4 * 4) - (4 / 4))
16 == (4 * (4 ** (4 / 4)))
17 == ((4 / 4) + (4 * 4))
18 ==
19 ==
20 == (4 * (4 + (4 / 4)))
21 ==
22 ==
23 ==
24 == (4 + (4 + (4 * 4)))
25 ==
26 ==
27 ==
28 == ((4 * (4 + 4)) - 4)
29 ==
30 ==
31 ==
32 == ((4 ** 4) / (4 + 4))
33 ==
34 ==
35 ==
36 == (4 + (4 * (4 + 4)))
37 ==
38 ==
39 ==
40 ==
41 ==
42 ==
43 ==
44 ==
45 ==
46 ==
47 ==
48 == (4 * (4 + (4 + 4)))
49 ==
50 ==

Y para los geeks codeadores como yo, este fue el script rubyistico que usé para calcular las cosas:

def template_expressions( leafs = 4 )
  return "4" if leafs == 1
  previous_level = template_expressions( leafs - 1 )
  previous_level.map do
    |expr|
    results = []
    (0...expr.length).each do
      |i|
      if expr[i..i] == "4"
        new_result = expr.clone
        new_result[i] = "(4 o 4)"
        results << new_result
      end
    end
    results
  end.flatten
end

OPERANDS = %W{+ - * / **}

def sample_evaluations( leafs = 4 )
  evaluations = {}
  exprs = template_expressions(leafs)
  exprs.each do
    |expr|
    sample_evaluations0( leafs, expr, evaluations )
  end
  evaluations
end

def sample_evaluations0( leafs, expr, evaluations )
  if leafs == 0
    begin
      evaluations[eval( expr )] = expr
    rescue ZeroDivisionError
    end
    return
  end
  
  OPERANDS.each do
    |op|
    new_expr = expr.sub( /o/, op)
    sample_evaluations0( leafs - 1, new_expr, evaluations )
  end
end

evaluations = sample_evaluations
(0..50).each { |i| puts "#{i} == #{evaluations[i]}" }

Happy hacking,
Aureliano.

como sacar numeros del 0 al 9 con los digitos 4 4 4 4

Hoy estaba mirando la página del Google Analytics del blog y encontré una busqueda muy rara que entró por acá: "como sacar numeros del 1 al 50 con los digitos 4 4 4 4". Estuve pensando un poco que quería decir e inventé que tenía que hacer operaciones aritméticas comunes sobre los 4 4s y obtener los números del 1 al 50.
Me salieron los números del 1 al 9 (y le agregué el cero de yapa). Los anoté en notación "ruby" para que puedan hacer cut&paste en el irb.
0: 4+4-4-4
1: (4+4)/(4+4)
2: (4/4) + (4/4)
3: (4+4+4)/4
4: (4**(4-4))*4
5: (4**(4-4))+4
6: ((4+4) / 4) + 4
7: (4+4) - (4/4)
8: 4+4+4-4
9: (4+4) + (4/4)

Ahora me queda la duda de si se pueden, o no, armar todos los números del 1 al 50 de esta manera. Quizás debería escribir un programita que prueba todas las opciones.

Happy hacking,
Aureliano.

Gitcasts

Hace un tiempo que estoy jugando con la idea de empezar a usar git como control de versiones. Pero como estoy acostumbrado a años de subversion, aunque entiendo que tiene ventajas, me cuesta mucho hacer el pase. Las cosas que me detienen son que tiene menos soporte en Windows, la integración con eclipse es peor y usamos subversion en el trabajo.
Las cosas que me tientan son que está bueno poder tener versiones sin conectarse a un server, que es una cosa nueva para aprender, que parece estar bien hecho y que hay un montón de gente usándolo y le sirve. La idea de usar un control de versiones distribuido me gusta mucho.
Así que me puse a usarlo en un proyectito que estoy haciendo para mi, y empecé a buscar como usarlo en internet. Y me encontré con unos screencasts que están re-buenos y quiero compartir con ustedes. Les recomiendo especialmente que vean el screencast de los slides de la rails-conf.

Me voy a dormir,
Aureliano.

¡Soy papá!

Update: pueden ver las fotos de Nico en su blog.

El sábado 28 de febrero (o sea, anteayer) a las 12:39 hs nació Nicolás, mi primogénito. Estoy muy contento y emocionado y quería compartir con ustedes la aventura del nacimiento.

Contracciones

El viernes, cuando llegué del laburo, mi mujer me dijo que estaba con contracciones. Ya había tenido contracciones antes pero no muy seguido. Alrededor de las 9 y media empezamos a medir cuándo empezaban. Y se hacían cada vez más frecuentes. A partir de las 11 (o 12) se estabilizaron cada 10 minutos (aprox). Las contracciones se hacían cada vez más fuertes y a la una y media yo me adelanté y saqué el auto de la cochera, lo puse en la puerta del edificio y subí el bolso con las cosas que teníamos preparado para el parto. También me tomé un café re-cargado para estar despierto cuando hiciera falta llevarla al hospital (en mi cabeza, en una media hora).
Pero me apuré al re-pedo. Las contracciones se estabilizaron en los 10' de frecuencia. Y con contracciones cada 10 minutos, la partera nos dijo que esperemos y que la llamemos cuando lleguen a ser cada 5'. Las contracciones siguieron cada 10' un par de horas más y yo encontré que las risas podían inducir partos. Así que primero estuve leyendole a Agus un montón de chistes malos que encontré x la web; y como no se reía, vimos ZooLander. Mientras tanto seguimos anotando las contracciones. Como había tomado un montón de café, no me podía dormir (aunque Agus me lo pidió). Alrededor de las 5AM (¿o 6?), se fue el efecto del café. Las contracciones seguían cada 10 minutos, pero un poco más dolorosas.
Palmé y me dormí. Me despertó Agus a las 9. Me dijo que las contracciones al fin eran cada 5 minutos. Así que habló con la partera y quedamos encontrarnos en la Suizo.

La Suizo

Llegamos antes de las 10 a la Suizo. Fuimos al tercer piso. Le dimos el carnet de OSDE de mi mujer a la recepcionista y nos encontramos con la partera. En ese momento, ella nos dijo que no había habitaciones y que nos ¡teníamos que ir!. También la revisó y vio que el cuello del útero estaba casi completamente borrado, y que tenía un poquitito de dilatación.
Bajamos y pedí en el Valet Parking que me devuelvan el auto. Evidentemente Nico no nacería ahí.
Después de esperar un rato largo (las calles de la zona están medio enquilombadas porque hicieron Pueyrredón doble mano) trajeron el autito y partimos a la clínica Otamendi, donde la partera hizo una reserva.

Llegando a la Otamendi

Dejé a Agustina e Irma en la puerta de la clínica, y fui a estacionar. El estacionamiento de esta clínica salía ¡$55 x día! y había cola. Así que me fui a buscar otro. Encontré uno a 2 cuadras a $35 x día, que abre las 24hs y estacioné ahí. Fui a la clínica, a admisiones. Yo tenía el carnet de OSDE de Agus así que terminé el trámite y subí a la habitación que le habían asignado.

Preparativos para el parto

Llegué a la habitación 509, que es la habitación que asignaron para que estuviera Agus hasta que liberen una de las de internación. Al toque la partera me dijo que fuera con ella a cambiarme para presenciar el parto.
Acá empezó el primer inconveniente. Llegué a una especie de vestuario en el sexto piso del Otamendi donde se suponía que me tenían que dar la ropa que hace falta para entrar en un quirófano y darme un locker para guardar la mía. En el vestuario lo que encontré es un montón de ambos de cirujía tirados, lockers cerrados, y médicos rapiñando los 3 que quedaban. La partera vio lo mismo en su vestuario y volvimos.
A Agus ya la habían preparado y estaba lista para ser mamá. Después de un ratito (que me pareció una eternidad), me trajeron la ropa para entrar a la sala de partos, me cambié, dejé las cosas en la habitación 509 (la enfermera me dijo que dejaban todo con llave) y fui con la partera al parto.

El parto

Entré a la parte de cirujía, y ya estaba todo encaminado. La partera fue derecho a la sala de partos y a mi me dijeron que espere un rato. Mientras tanto me puse unas cosas para cubrir las zapatillas y otra para el pelo. Esperé un rato, y pedí si podía entrar. La enfermera que estaba en la puerta de la sala de parto me dijo que sí.
Entré y estaba el obstetra de Agus metiéndole una barreta en la cachucha. Por lo que había leído, hacen eso para romper la bolsa así que no me asusté. Rompió la bolsa, empezaron las contracciones fuertes, Agus imploró x la peridural y, después de chequear que el bebé esté bien, decidieron dársela. Ahí me echaron de la sala.
Esperé un rato más y volví a preguntar si podía entrar. De nuevo dijeron que sí. Cuando volví apoyaron la piernas de Agus levantadas a 90 grados. El parto, inminente. Aún con peridural a Agus le dolían muuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuucho las contracciones, así que aprovechando que ya tenía puesto un cateter en la espalda le dieron una segunda dosis. Después de eso hizo los pujos y salió Nicolás. A los 5 segundo de salir empezó a llorar. Cortaron el cordón umbilical y lo apoyaron un segundo sobre Agus.

Chequeos varios

Tal como me dijeron en el curso de preparto, ahí mismo dejé a mi mujer para que haga el alumbramiento (o sea, que expulse la placenta) y me fui siguiendo a mi flamante hijo. En una sala aledaña lo pesaron, midieron, le pusieron las pulseritas identificatorias y lo limpiaron un poco. Cuando terminaron, me lo dieron para que lo alce. Y se lo llevé a Agus, que había terminado de expulsar la placenta. Pusieron el bebé encima de Agus un toque más, terminamos algo de papeleo (incluyendo que me dieron el certificado de nacimiento) y vinieron de Nursery a llevarse al bebé. Yo me fui con el bebé.

El dilema

Todavía seguía en la 509. La hab. 509 es muy pequeña y era incómod estar ahí. Así que cuando la "nurse" me dijo si me llevaba al bebé directamente o dejaba que lo lleven un ratito a la nursery para acicalarlo, dudé un toque y después decidí que lo mejor era que se lo llevaran. Yo me fui a cambiar a la habitación (todavía tenía la ropa del quirófano).

La tarde

Llegué a la habitación, me cambié y al toque apareció Agustina, que me cagó a pedos porque dejé que se lleven a Nicolás a la nursery. Le expliqué que dejé que fuera porque me pareció lo mejor, porque la habitación es chiquita, etc y, por suerte, al toque lo trajeron así que la discusión se desvaneció. Esperamos un ratito y me puse a preguntar cuando nos pasaban a una habitación decente, sin conseguir demasiadas respuestas.
A las 2 de la tarde (más o menos), bajé a Admisiones para que me informen cuándo iba a tener el pase de habitación. No solo no había nadie, tampoco había nadie en la recepción y había gente haciendo cola hacía 45', para que los atiendan. Subí al quinto piso a acompañarla a Agus (Nico estaba frito) y al ratito volví a bajar.
Cuando bajé de nuevo, atendían en recepción así que me quejé de que antes no había nadie y que tuve problemas con la ropa para entrar a la sala de parto. Dejé una nota por escrito en la hoja 188 del libro de quejas. Si pasan por el sanatorio pueden pedirlo para leerla. También hablé con la supervisora de hotelería un rato y me quejé de que la habitación era muy chica, de que no tiene baño, de que no puedo recibir gente (y es un nacimiento), de que no había gente en Admisiones ni en recepción, que no andaba el interno de la hab. 509, etc. O sea, le quemé la cabeza. La mina me prometió que iba a hacer todo lo que pudiera y que iba a tener la habitación ese mismo día, así que volví al quinto piso. Después de un rato, llamó la mina diciendome que ya tenían habitación para nosotros. La 321. La 321 es una habitación de más categoría de lo que cubre mi plan de OSDE, tiene recepción, es grande y me la bonifican. Parece que quejarme sirvió.
Llegaron mi suegra y mi cuñada a la hab. chiquita, porque Agus quería que vinieran. Entró mi suegra a la hab y me quedé afuera hablando con mi cuñada. Después nos avisó la enfermera que nos asignaron la habitación y al ratito vienen a buscar a Nicolás para llevarlo. Me voy con los bolsos y él a la nueva habitación.
La nueva habitación (tal como me dijeron) estaba re-buena. Grande, luminosa, cómoda. Dejo durmiendo a Nico y me pongo a ver tele. Llegan Agus y su parentela están un rato más y se van. La verdad que estabamos muertos. A las 8 le traen la cena a Agus, yo compro un sanguche (que estaba bárbaro) en el restaurant del hotel y me lo traen a la habitación. Cenamos, nos bañamos, y a las 9 palmé.

Segundo día

Día de visitas. A la mañana vienen mis hermanos, mi tía y mis viejos. Se quedaron un rato (después aprenderíamos que demasiado). Al mediodía viene la puericultora y descubrimos que Nico no está tomando la teta bien. Después de debuggear el problema un rato, llega a la conclusión de que Nico no toma porque los pezones de Agus son muy chiquitos y no sabe succionar todavía. Para workarroundear el problema, compramos unas pezoneras, y Nico se prendió. Y la puericultora nos dijo que tengamos a ralla a las visitas para captar las señales "de teta" de Nico.
A la tarde vinieron mi abuela con mi vieja y su primo Gregory, que me cuidaba de chico, y que es como un tío para mi, y que ahora vive en Israel. También vinieron mi cuñado y su hija y una tía de Agustina. A todos les dije que estén poco tiempo porque nos dijo la puericultora.
A la noche la llamamos a mi suegra para coordinar la salida de la clínica. Ella nos ayudó a irnos de la clínica.

Chau clínica

Nos levantamos a la mañana. Llevaron a Nico a hacer unos exámenes (donde le pincharon el talón, pobrecito), fui a hacer el trámite administrativo del alta (o sea, pagar), inicié el trámite del DNI de Nico y nos quedamos esperando a la neonatóloga. Alrededor del 1/2 día llegó mi suegra. A las 12:30hs (o sea, media hora después de la hora del alta) fui a averiguar xq no venía la neonatóloga. Después de como 1 hora de quilombo, exigí que le dieran el almuerzo a Agus; compré 2 sanguches para mi suegra y yo y llegó la neonatóloga, que adujo que no sabía que tenía que darnos el alta. Revisó a Nicolás, lo llevó a la nursery para hacerle el control oftalmológico, terminamos de comer, e hicimos el alta.

La vuelta

Bajamos y fuimos a la puerta de la clínica. Yo agarré el bolso y me fui a buscar el auto. Arranqué el auto y lo llevé hasta la puerta de la clínica. Mientras venía, atrás a la derecha el auto hacía un ruido raro. Cuando andaba más rápido el ruido era más rápido.
Llegué a la clínica, subí con dificultad el asiento de Nico al auto y lo encastré en la base y me di cuenta que la rueda trasera derecha estaba completamente desinflada. Saqué la sillita y Agus y la mamá se fueron en un taxi. Yo abrí el baúl, saqué el tapizado, saqué la rueda de auxilio, saqué el crique y la llave. Aflojé la rueda desinflada, subí el auto con el crique, cambié la rueda y fui solo para casa.
Cuando llegué a casa a las 4 de la tarde, me la encontré a mi suegra cuidando a mi nene y a mi mujer durmiendo, palmada. Y yo al borde de un ataque de nervios. Mi suegra se fue porque tenía que ir a trabajar y me quedé cuidando a Nico que, por suerte, estaba dormido.

Rakefile multiplataforma para erlang

Los últimos días estuve programando un toque en Erlang. Como estoy tratando de armar un proyectito algo más en serio, necesito algo como un makefile. Y como los makefiles son un dolor de huevos, decidí que es mejor hacer un rakefile.
Para eso estuve googleando un poco y encontré este post. Que casi resolvía los quilombos, pero le falta poder andar en Windows. Así que lo toquetié un poco para hacerlo multiplataforma.
Las cosas que tuve que hacer son:

• Usar ruby en vez de llamar a pwd para obtener el path actual.
• Generar nombres de archivos con back-slashes.
• Hacer que maneje bien cosas con espacios.

Para obtener el PATH actual hice esto:

PWD = Pathname(".").realpath

Para que el Pathname fuera con backslashes, después de consultarlo con Luis Lavena, monkey-patchié Pathname para que el to_s mande "back-slashes":

#Hack to generate paths with back-slashes
class Pathname
 alias_method :old_to_s, :to_s
 def to_s
   File::ALT_SEPARATOR ? old_to_s.gsub(File::SEPARATOR,File::ALT_SEPARATOR) : old_to_s
 end
end

Por último, cambié un toque las llamadas a "sh" para que maneje paths con espacios. Para eso, en vez de pasarle un String le paso un Array por parámetro. Las llamadas quedaron algo así:

sh *%W{erl -switch param1 #{param_calculado}}

Al final, el Rakefile quedó así:

#Based on the Rakefile shown in http://medevyoujane.com/blog/2008/8/21/erlang-make-rake-and-emake.html

require 'rake'
require 'rake/clean'
require 'pathname'

#Hack to generate paths with back-slashes
class Pathname

alias_method :old_to_s, :to_s

def to_s
 File::ALT_SEPARATOR ? old_to_s.gsub(File::SEPARATOR,File::ALT_SEPARATOR) : old_to_s
end
end


# Configuration
START_MODULE = "hellman"
TEST_MODULE = "TEST MODULE NOT DEFINED"

# No Need to change
PWD = Pathname(".").realpath
INCLUDE = "include"
ERLC_FLAGS = "-I#{INCLUDE} +warn_unused_vars +warn_unused_import"

SRC = FileList['src/**/*.erl']
OBJ = SRC.pathmap("%{src,ebin}X.beam")
CLEAN.include(['**/*.dump'])
CLOBBER.include(['**/*.beam'])

directory 'ebin'

rule ".beam" =>  ["%{ebin,src}X.erl"] do |t|
 sh *%W{erlc -pa ebin -W #{ERLC_FLAGS} -o ebin #{t.source}}
end

desc "Compile all"
task :compile => ['ebin'] + OBJ

desc "Open up a shell"
task :shell => [:compile] do
   sh *%W{erl -sname #{START_MODULE} -pa #{PWD + 'ebin'}}
end


desc "Open up a shell and run #{START_MODULE}:start()"
task :run => [:compile] do
   sh *%W{erl -sname #{START_MODULE} -pa #{PWD + 'ebin'} -run #{START_MODULE} start}
end

desc "Run Unit Tests"
task :test do
 sh *%W{erl -noshell -s #{TEST_MODULE} test -s init stop}
end

task :default => :compile

Happy jakin,
Aureliano.

Traducciones hollywoodenses

Después de ir todos los mediodías a diversos restaurantes de Palermo Hollywood pude recabar información sobre el "argot" que usan para escribir las cartas. Estas son algunas de las cosas que pude entender hasta ahora:

• colchón de verdes: ¡uy!, no compramos tomates.
• a las finas hierbas: en una de esas le ponemos perejil.
• papas rústicas: íbamos a hacer papas fritas pero nos dio mucha vagancia pelar las papas.
• pezca del día: es lo más barato que había en la pezcadería.
• menú ejecutivo: al mediodía son todos unos ratas, así que hay que darles algo barato.
• brusquetas: nos sobró pan duro de ayer.
• cocina gourmet: vamos a darte re-poca comida, te vas a quedar con mucha hambre y te vamos a cobrar un fangote de guita. Eso sí, cuando te llevemos el plato vas a decir "¡qué lindo! parece un cuadro"
• spring-roll: arrolladito primavera, pero todavía más chiquito
• explosión de vegetales: Lo que me sobró de ayer le agregué un huevo y lo cociné, AKA: "revuelto de gramajo".
  

Aureliano.

C++ frequently questioned answers

La obra de Yossi Kreinin en su C++ Frequently questioned answers es soberbia. Cientos y cientos de Kbytes dedicados exclusivamente a explicar porqué no usar C++ para empezar proyectos nuevos de desarrollo de software (cosa que comparto) y explicar las falencias de C++ detalladamente (y, la verdad, las falencias están bien justificadas).

Con un estilo ácido, ágil y de fácil lectura, demuele carta a carta ese castillo de naipes que es C++. No puedo hacer más que recomendar la lectura de esta excelente página.

Happy hacking (pero no en C++),
Aureliano.

Números de Aure

Update: Los números de Aure también se llaman A131689

La oficina de Agustina tiene en la puerta un teclado donde hay que ingresar una clave para poder entrar. Pensando en esto (y otras cosas donde hay que ingresar claves numéricas, como los cajeros automáticos) se me ocurrió el siguiente problema:

Hay que elegir un número de 6 dígitos (en base 10, con posibles 0s
adelante) como clave para ingresar en un pinpad para ingresar a una "habitación segura".
Pero un atacante tiene la posibilidad de leer huellas digitales y por lo tanto sabe que teclas apretaste pero no en que orden ni con que repetición (o sea, no puede distinguir las claves "111112" y "122222").

¿Cómo se debe elegir la clave de tal manera que el atacante tenga la mayor dificultad posible para adivinarla?

Este problema lo postié en los news internos del laburo y Charles, un compañero de laburo, se mandó una explicación buenísima en dos mensajes. Abajo pongo textuales los mails:

Primer mail:

Con 6 digitos hay 6! = 720 posibilidades.

Con 5 digitos, una forma de contar es así: supongamos que los digitos son 1,2,3,4,5 y que el 5 está repetido dos veces, lo contamos como 1,2,3,4,5a,5b y despues dividimos por las permutaciones de 5a y 5b. Eso da 6! / 2!, y como hay 5 posibilidades para el digito repetido el
resultado es:
6! / 2! * 5 = 1800 posibilidades.

Con 4 digitos, puede haber un digito repetido tres veces, por ejemplo 1,2,3,4a,4b,4c
Posibilidades 6! / 3! * 4 = 480
Puede haber dos digitos repetidos dos veces cada uno, por ejemplo 1,2,3a,3b,4a,4b
Posibilidades 6! / (2! * 2!) * Combinatorio(4,2) = 1080 El Combinatorio(4,2) es la cantidad de formas de elegir 2 elementos entre 4, es 4! / (2!*2!) = 6
En total: 1560 posibilidades con 4 digitos

Con 3 digitos, las estructuras son 1,2,3a,3b,3c,3d da 6! / 4! * 3 = 90
1,2a,2b,3a,3b,3c da 6! / (3! * 2!) * (3*2) = 360 1a,1b,2a,2b,3a,3b da 6! / (2! * 2! * 2!) = 90
Total: 540 posibilidades con 3 digitos

Con 2 digitos, las estructuras son 1,2a,2b,2c,2d,2e da 6! / 5! * 2 = 12
1a,1b,2a,2b,2c,2d da 6! / (4! * 2!) * 2 = 30 1a,1b,1c,2a,2b,2c da 6! / (3! * 3!) = 20
Total: 62 posibilidades con 2 digitos

Con 1 digito, hay 6! / 6! = 1 posibilidad (claro ;-)

Conclusión: hay que usar 5 digitos!

Segundo mail:

Me quedé pensando en tratar de sacar una relación de recurrencia...
Llamemos "número de Aure" A(k,n) a la cantidad de claves de n digitos que usen exactamente k digitos distintos. Por ejemplo 1,2,2,3,3 es una clave de 5 digitos que usa 3 digitos distintos.

Yo lo pienso como cantidad de claves con k digitos distintos en n lugares.

Los casos faciles:
A(1,n) = 1 para todo n
A(k,n) = 0 si k > n

Ahora la recurrencia: si tengo una clave con n-1 lugares, hay dos opciones: ya se usaban los k digitos en los n-1 lugares, o solo se usaban k-1 digitos distintos y agregué el k-ésimo digito en el ultimo lugar.

Si ya se usaban k digitos en n-1 lugares, tengo k posibilidades para el n-esimo lugar (repetir uno de los k digitos).

Si se usaban exactamente k-1 digitos en n-1 lugares, entonces estoy agregando un digito nuevo en el n-ésimo lugar. Tengo k opciones para el digito nuevo.

Luego A(k,n) = k * A(k,n-1) + k * A(k-1,n-1)

A(k,n) = k * ( A(k,n-1) + A(k-1,n-1) )

Es como un triangulo de Pascal con un multiplicador k.

Las primeras filas dan:

       k=1     k=2     k=3     k=4     k=5     k=6
n=1     1       0
n=2     1       2       0
n=3     1       6       6       0
n=4     1       14      36      24      0
n=5     1       30      150     240     120     0
n=6     1       62      540     1560    1800    720     0

Sorprendentemente, volvió a dar los mismos números ;-)

La problema de Aure se puede reformular como "qué k maximiza A(k,6)?"

En fin, el problema parece que dio para mucho :D, y tengo mis propios números con una serie que tiene un sentido y una "aplicación".

Happy hacking,
Aureliano.

Mirando android

Hoy estuve mirando un toque como hacer una aplicación en Android. Después de hacer el HelloWorld correspondiente, seguir parte del tutorial sobre como hacer una aplicación que sirva para guardar notas y leer bastante de la documentación, hice correr el Lunar Lander. El Lunar Lander es un port del archi-conocido juego al android.
Pensé que iba a salir de toque, pero no :(. Así que puse manos a la obra, toque las 2 tonteras que tenía mal y lo hice andar. Para que no tengan que hacer lo mismo que yo, les dejo mi proyecto de eclipse armado. Es igual al de los ejemplos de Google salvo porque como package uso aure en vez de com.android.examples.
Acá está el tar.gz.
Happy hacking,
Aureliano.

Proyecto Euler: Problemas 19 a 21

Sigo avanzando con los ejercicios del proyecto Euler. Les cuento los siguientes 3 ejercicios.
EL ejercicio 19 consiste en contar la cantidad de domingos del siglo 20. Primero pensé en hacer un montón de aritmética modular para resolver esto, pero después se me ocurrió una idea mejor. Así que usé la biblioteca de fechas de ruby, iteré por todos los días de enero del siglo 20 y sumé todos los domingos. Acá abajo pongo el código:

require 'date'

sundays = 0
(1901..2000).each do
  |year|
  Date.civil(year,1,1).upto(Date.civil(year,1,31)) do
    |d|
    sundays += 1 if d.wday == 0 # is sunday
  end
end

puts "# of sundays in the 20th century: #{sundays}"

El resultado de la corrida (casi instantáneo) es:

$ ruby euler19.rb
# of sundays in the 20th century: 443

El ejercicio 20 consiste en encontrar la suma de los dígitos de 100!. Usando las funciones para obtener cada dígito de un número del ejercicio 16, se hace bastante fácil. Este es el código:

class Integer
  def digit(pos)
    (self / (10 ** pos)) % 10
  end
  def digit_count
    dc = 0
    while self - (10 ** dc) > 0
      dc += 1
    end
    dc += 1 if self % (10 ** dc) == 0
    dc
  end
end

fact100 = (1..100).inject { |prod,n| prod * n }
puts "Digits: #{fact100}"
puts "Sum: #{(0...(fact100.digit_count)).inject {|s,n| s + fact100.digit(n)}}"

Y el resultado de la ejecución (también instantánea) es:

$ ruby euler20.rb
Digits: 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000
Sum: 648

El ejercicio 21 es el más complicado de los 3. Consiste en sumar todos los números naturales "amigables" menores a 10000. Un par de números (a,b) es amigable si la suma de los divisores de a (excluyendo a) es b y la suma de los divisores de b (excluyendo b) es a. Un número es amigable si pertenece a un par amigable. Lo que se me ocurrió fue usar el MemoFactorizator (factorizador de números que recuerda factorizaciones previas) del ejercicio 12 para calcular las factorizaciones de todos los números menores a 10000. Usando esto, calculé analíticamente las sumas de los divisores propios (hay una fórmula re-linda que sale de la factorización, pero como no puedo escribir LaTeX facilmente acá, mejor mirenla en el código). Y habiendo calculado todas las sumas de los divisores, buscar en orden n todos los números amigables. Acá está el código:

class OddPrimes
  def initialize
    @current = 1
    @primes = []
  end
  attr_reader :current
  def next
    while not prime?(@current += 2)
    end
    @primes << @current
    @current
  end
  
  def prime?(n)
    i = 0
    p = 1
    while true
      break if i >= @primes.length
      p = @primes[i]
      break if p * p > n
      break if n % p == 0
      i += 1
    end
    return i >= @primes.length || p * p > n
  end
end

class Primes < OddPrimes
  def initialize
    super
    @first = true
  end
  def next
    if @first
      @first = false
      2
    else
      super
    end
  end
  def current
    odd_super = super
    odd_super == 1 ? 2 : odd_super
  end
end

class MemoFactorizator
  attr_reader :factored
  def initialize
    @factored = {1 => {} }
  end
  def factorize(n, pg = Primes.new)
    return @factored[n] if @factored.include?( n )
    p = pg.current
    while n % p != 0
      p = p.next
    end
    factorization = factorize( n / p, pg ).dup
    factorization[p] = factorization.include?(p) ? factorization[p] + 1 : 1
    @factored[n] = factorization
    factorization
  end
end

def divisor_sum(n, factorization)
  acum = 1
  factorization.each_pair do
    |p,pow|
    acum *= (0..pow).inject(0) { |s,i| s + p ** i }
  end
  acum - n
end

MAX = 10000

mf = MemoFactorizator.new
(2...MAX).each do
  |n|
  mf.factorize(n)
end

sums = {}
(2...MAX).each do
  |n|
  sums[n] = divisor_sum(n, mf.factored[n])
end

amicable = []

(2...MAX).each do
  |n|
  amicable << n if n == sums[sums[n]] and n != sums[n]
end

puts "Amicable numbers: #{amicable.inspect}"
puts "Sum: #{amicable.inject {|s,n| s+n}}"

La ejecución tardó un poquito (unos 4 segundos) y dio este resultado:

$ time ruby euler21.rb
Amicable numbers: [220, 284, 1184, 1210, 2620, 2924, 5020, 5564, 6232, 6368]
Sum: 31626

real    0m4.681s
user    0m4.560s
sys     0m0.108s

Happy hacking,
Aureliano

Proyecto Euler: Problemas 16 a 18

Update: Reporto la suma en el ejercicio 18.

Sigo con mi maratón euleriana. Ahora resolví los problemas 16 a 18.
El problema 16 consiste en encontrar la suma de los dígitos de 2^1000. Para eso desenpolvé la lógica para obtener la cantidad de dígitos de un número y qué dígito es que había hecho para el problema 4 (pequeño quiz: ¿qué bug le arreglé?) calculé 2^1000 y sumé los dígitos. Este es el código:

class Integer
  def digit(pos)
    (self / (10 ** pos)) % 10
  end
  def digit_count
    dc = 0
    while self - (10 ** dc) > 0
      dc += 1
    end
    dc += 1 if self % (10 ** dc) == 0
    dc
  end
end

n = 2 ** 1000
digits_sum = (0..(n.digit_count)).inject(0) { |sum, pos| sum += n.digit(pos) }
puts digits_sum

Y este el resultado (que sale instantáneamente):

$ ruby euler16.rb
1366

El problema 17 consiste en calcular cuantas letras (con repeticiones) hay en los números del 1 al mil en inglés. Por ejemplo "one two three" tiene 11 letras. Para eso hice una rutina que genera las palabras asociadas a cada número entre 1 y 1000, eso generó un string. Al string le saqué los espacios y conté la cantidad de caracteres. Mientras lo hacía me acordé de cuando estuve probando unos de los ejercicios que usan en ITA para contratar gente, pero lo escribí todo de 0. Acá va el código:

class Integer
  UNITS = ["","one","two","three","four","five","six","seven","eight","nine"]
  TEENS = ["ten","eleven","twelve","thirteen","fourteen","fifteen","sixteen","seventeen","eighteen","nineteen"]
  TENS = ["","","twenty","thirty","fourty","fifty","sixty","seventy","eighty","ninety"]
  def to_words
    raise Exception.new("Don't know how to say in words the number #{self}") unless (1..1000).include? self
    return "one thowsand" if self == 1000
    words = []
    if self >= 100 then 
      words << UNITS[self / 100]
      words << "hundred"
    end
    words << "and" if (self % 100) != 0
    case (self % 100) / 10
      when 1
        words << TEENS[self%10]
      else
        words << TENS[(self % 100) / 10]
        words << UNITS[self % 10]
    end
    return words.delete_if{|w| w == ""}.join(" ")
  end
end

char_count = (1..1000).inject(0) { |sum,n| sum + n.to_words.gsub(" ","").length }
puts char_count

Y la corrida (también instantánea):

$ ruby euler17.rb
21521

Por último hice el ejercicio 18, que es el más interesante de los 3. El mismo consiste en navegar por un triángulo (que pongo más abajo), encontrando el camino desde arriba de todo a algún numerito de abajo de tal manera que la suma de los nodos del camino sea lo mayor posible.

75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23

Para resolver este problema, calculé las sumas de los mejores caminos posibles para todos los subtriangulos y después, usando eso, elegí en forma greedy el mejor camino. Acá va el código:

data_text = <<DATA_TEXT
75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23
DATA_TEXT

data = data_text.split("\n").map{ |row_text| row_text.split(" ").map{ |cell_text| cell_text.to_i(10) } }
sums = Array.new(data.length)
sums[-1] = data[-1].dup
(2..(data.length)).each do
  |row|
  sum = []
  prev_sum = sums[-row+1]
  data[-row].each_with_index do
    |v,i|
    sum[i] = v + [prev_sum[i],prev_sum[i+1]].max
  end
  sums[-row] = sum
end

pos = 0
path = []

(1..(data.length - 1)).each do
  |row|
  if sums[row][pos] > sums[row][pos+1] then
    path << :left
  else
    path << :right
    pos += 1
  end
end

puts path.inspect
puts "Sum: #{sums[0][0]}"

Y este es el resultado de la ejecución (también instantáneo, ya que se hacen tantas sumas como subtriángulos no triviales (que son menos que la cantidad de números en el triángulo) y tantas elecciones como la altura del triángulo. Acá les muestro el resultado:

$ ruby euler18.rb
[:right, :right, :left, :left, :right, :left, :left, :right, :right, :right, :right, :right, :left, :right]
Sum: 1074

Happy hacking,
Aureliano.

Proyecto Euler: Problemas 13 a 15

Los problemas 13 a 15 resultaron más faciles que el 12. El 13 consiste en saber los primeros 10 dígitos de una suma de 100 números re-grandes. Como ruby soporta números arbitrariamente grandes, una vez que obtuve los números lo resolví en un one-liner:

data_text = <<DATA_TEXT
37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690
DATA_TEXT

puts (data_text.split("\n").map { |n| n.to_i(10) }.inject(0) { |sum,n| sum + n }).to_s[0..9]

El resultado fue (solo por curiosidad):

$ ruby euler13.rb
5537376230

Y la corrida fue casi instantánea.
El problema 14 consiste en buscar el número menor a 1000000 que genera la secuencia de Collatz más grande. La secuencia de Collatz se calcula así:

• Si n es 1, terminó
• Si n es par, es n:collatz(n/2)
• Si n es impar, es n:collatz(n*3 + 1)

Este problema se resuelve con un poco de memoization:

class PathLengthMemoizator
  def initialize
    @lengths = {1 => 0}
    @max_n = 1
  end
  attr_reader :max_n
  
  def max_length
    @lengths[max_n]
  end
  
  def calculate_length(n)
    return @lengths[n] if @lengths.include?(n)
    @lengths[n] = calculate_length( n % 2 == 0 ? n/2 : 3*n + 1 ) + 1
    @max_n = n if @lengths[n] > @lengths[@max_n]
    @lengths[n]
  end
end

plm = PathLengthMemoizator.new
(1...1000000).each do
  |n|
  plm.calculate_length(n)
end
puts "Longest path number: #{plm.max_n}"
puts "Length: #{plm.max_length}"

Y cuando lo corrí, dio este resultado:

$ time ruby euler14.rb
Longest path number: 837799
Length: 524

real    0m15.058s
user    0m13.609s
sys     0m1.284s

El problema 15 es el más interesante. En un cuadriculado de tamaño 20 * 20, yendo por las rayitas para abajo y a la derecha, ¿cuántas formas hay de ir desde la posición (0,0) hasta la (20,20)? En un principio, parecía un quilombo. Pero, calculando cuantos caminos hay desde (0,0) hasta (X,Y) me di cuenta que en las diagonales se armaba el Triángulo de pascal. Entonces, mirando fijo, me salió la fórmula general para calcular cuantos caminos hay hasta (X,Y) desde (0,0). Es (X*Y)! / (X! * Y!).
Aplicando la fórmula a la coordenada (20,20) queda 40! / (20! * 20!), que corriendo en el irb queda así:

$ irb
irb(main):001:0> class Integer
irb(main):002:1>   def fact
irb(main):003:2>     (1..self).inject(1) { |f,n| f*n }
irb(main):004:2>   end
irb(main):005:1> end
=> nil
irb(main):006:0> 40.fact / (20.fact * 20.fact)
=> 137846528820

Habiéndo resuelto el problema en forma elegantísima, me voy a dormir antes que encuentre otro.
Happy hacking,
Aureliano.

Proyecto Euler: Problema 12

Sigo enfermo con el proyecto Euler. Y ya hice el problema 12. El mismo consiste en encontrar el primer número triangular con más de 500 divisores. Un número triangular es de la forma 1 + 2 + 3 + ... + n. Y, se puede calcular rápidamente como n*(n+1)/2.
Mi primer intento de resolución (que anduvo pero fue lento) consistió en usar el generador de números primos del ejercicio 3 para calcular la cantidad de divisores del número, calculándolo directamente. Acá va el código:

class Integer
  def triangle
    (self * (self + 1)) / 2
  end
  def divisor_count
    n = self
    pg = Primes.new
    count = 1
    while n != 1
      p = pg.next
      pow = 0
      while n % p == 0
        pow += 1
        n /= p
      end
      count *= (pow + 1)
    end
    count
  end
end

class OddPrimes
  def initialize
    @current = 1
    @primes = []
  end
  attr_reader :current
  def next
    while not prime?(@current += 2)
    end
    @primes << @current
    @current
  end
  
  def prime?(n)
    i = 0
    p = 1
    while true
      break if i >= @primes.length
      p = @primes[i]
      break if p * p > n
      break if n % p == 0
      i += 1
    end
    return i >= @primes.length || p * p > n
  end
end

class Primes < OddPrimes
  def initialize
    super
    @first = true
  end
  def next
    if @first
      @first = false
      2
    else
      super
    end
  end
  def current
    odd_super = super
    odd_super == 1 ? 2 : odd_super
  end
end

n = 1
while n.triangle.divisor_count <= 500
  n += 1
end

puts "Triangle #{n} (#{n.triangle}) is the first with over 500 divisors"

Anduvo, pero la corrida tardó como 4 minutos. Este es el resultado:

$ time ruby euler12.rb
Triangle 12375 (76576500) is the first with over 500 divisors

real    4m17.556s
user    3m57.519s
sys     0m16.117s

Así que me puse a pensar como hacer para que ande más rápido. Se me ocurrieron varias cosas:

• Puedo calcular la factorización de n*(n+1)/2 sabiendo la factorización de n y n+1
• Puedo calcular la factorización de cada número una sola vez (guardando factorizaciones viejas)
• La factorización la puedo escribir recursivamente para usar las factorizaciones que ya calculé

Usando todo esto, hice una nueva implementación:

class OddPrimes
  def initialize
    @current = 1
    @primes = []
  end
  attr_reader :current
  def next
    while not prime?(@current += 2)
    end
    @primes << @current
    @current
  end
  
  def prime?(n)
    i = 0
    p = 1
    while true
      break if i >= @primes.length
      p = @primes[i]
      break if p * p > n
      break if n % p == 0
      i += 1
    end
    return i >= @primes.length || p * p > n
  end
end

class Primes < OddPrimes
  def initialize
    super
    @first = true
  end
  def next
    if @first
      @first = false
      2
    else
      super
    end
  end
  def current
    odd_super = super
    odd_super == 1 ? 2 : odd_super
  end
end

class MemoFactorizator
  def initialize
    @factored = {1 => {} }
  end
  def factorize(n, pg = Primes.new)
    return @factored[n] if @factored.include?( n )
    p = pg.current
    while n % p != 0
      p = p.next
    end
    factorization = factorize( n / p, pg ).dup
    factorization[p] = factorization.include?(p) ? factorization[p] + 1 : 1
    @factored[n] = factorization
    factorization
  end
end

n = 1
mf = MemoFactorizator.new
while true
  fact_n = mf.factorize(n)
  fact_nn = mf.factorize(n+1)
  triangle_factorization = fact_n.merge(fact_nn) { |k,old,new| old + new }
  triangle_factorization[2] -= 1
  
  divisor_count = triangle_factorization.values.inject(1) { |c,pow| c*(pow+1) }
  break if divisor_count > 500
  n += 1
end

puts "First triangle: #{n} (#{n*(n+1)/2})"
puts "Factorization: #{triangle_factorization.inspect}"
puts "Divisor count: #{divisor_count}"

La nueva implementación tardó 6 segundos en correr.

$ time ruby euler12.rb
First triangle: 12375 (76576500)
Factorization: {5=>3, 11=>1, 17=>1, 7=>1, 13=>1, 2=>2, 3=>2}
Divisor count: 576

real    0m6.690s
user    0m6.568s
sys     0m0.100s

Ahora estoy contento porque dio el mismo resultado que la vez anterior pero mucho más rápido y con código más lindo.

Happy hacking,
Aureliano.

Cumplí 0x20

El 18 cumplí años de nuevo. Parece que es cada vez más rápido.

Un poquito más del proyecto Euler

Sigo enfermo resolviendo ejercicios del proyecto euler. Hoy resolví el ejercicio 11. El mismo consiste en encontrar en una matriz de 20x20 los cuatro números consecutivos en una misma línea (que puede ser horizontal, vertical o diagonal en cualquiera de sus 2 variantes) tal que su multiplicación sea lo más grande posible.
He aquí el código fuente en ruby:

require 'matrix'

RAW_DATA = <<RAW_DATA
08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48
RAW_DATA
data = Matrix[*RAW_DATA.split("\n").map { |row| row.split(" ").map { |n| n.to_i(10) } }]

DIRECTIONS = [[1,0],[0,1],[1,1],[1,-1]]
best_product = -1
best_row = -1
best_col = -1
best_dir = [0,0]

DIRECTIONS.each do 
  |dir|
  (0...20).each do 
    |row|
    (0...20).each do 
      |col|
      product = (0...4).inject(1) do 
        |prod, pos|
        target_row = row + pos * dir[0]
        target_col = col + pos * dir[1]
        (0...20).include?(target_row) && (0...20).include?(target_col) ? prod * data[target_row, target_col] : 0
      end
      if product > best_product then
        best_product = product
        best_row = row
        best_col = col
        best_dir = dir
      end
    end
  end
end

puts "Product: #{best_product}"
puts "Row: #{best_row}"
puts "Col: #{best_col}"
puts "Dir: #{best_dir.inspect}"

(0...4).each do 
  |pos|
  target_row = best_row + pos * best_dir[0]
  target_col = best_col + pos * best_dir[1]
  puts "Position: #{target_row}, #{target_col}"
  puts "Value: #{data[target_row, target_col]}"
end

Y para que vean cuanto dio, esta es la salida de la corrida

Product: 70600674
Row: 12
Col: 6
Dir: [1, -1]
Position: 12, 6
Value: 89
Position: 13, 5
Value: 94
Position: 14, 4
Value: 97
Position: 15, 3
Value: 87

Me voy a dormir.
Happy hacking,
Aureliano.

Algunas verdades y mentiras infundadas del desarrollo de software

• Java es el nuevo Cobol
• Eclipse es el nuevo emacs
• Java es lento
• Ruby es lento
• C es rápido
• C++ es rápido
• PHP es una bosta
  
• Las 3 virtudes de un gran programador son la pereza, la impaciencia y la soberbia
• Haciendo test-first y refactoring se puede mantener la calidad del código
• Los sistemas en producción tienen código fuente feo
• Haciendo test-first y refactoring no se hacen sistemas que queden en producción
• Los programadores tienen pocas habilidades interpersonales
• Los programadores deben hablar con los clientes para hacer los desarrollos
• Barato, rápido, bueno: elija 2
• Programando en Rails un programador es 10 veces más productivo que programando en J2EE
• Lisp es el mejor lenguaje de programación
• Smalltalk es el mejor lenguaje de programación
• A python hay que agregarle closures y sería un lenguaje espectacular
• Los verdaderos programadores programan en Fortran
• Los verdaderos programadores programan en C++
• Los verdaderos programadores programan en Assembler
• Los verdaderos programadores programan en código máquina
• Los verdaderos programadores silvan en el teléfono para transmitir datos a un modem, hacer un buffer overflow y reprogramar el server

Happy hacking,
Aureliiano.

Proyecto Euler - Problemas 5 a 10

Sigo a full con el Proyecto Euler. Y hoy hice 6 problemas. Les cuento como los solucioné:
El problema 5 es bastante fácil. Esencialmente se trata de encontrar el mínimo común múltiplo de los números 1..20. Lo más molesto es que ni el divisor común mayor ni el mínimo común múltiplo están en mi versión de ruby (ruby 1.8.6 patchlevel 111, ubuntu hardy), así que lo implementé:

class Integer
 def gcd(other)
   values = [self > 0 ? self : -self, other > 0 ? other : -other]
   a = values.min
   b = values.max
   while (a != 0)
     a, b = b % a, a
   end
   b
 end
 def lcm(other)
   self * other / self.gcd(other)
 end
end

puts (2..20).inject(1) {|ac, n| ac.lcm(n)}

Sólo por curiosidad, el número me dio 232792560.
El problema 6 es calcular la diferencia entre la suma de los cuadrados y el cuadrado de la suma de una secuencia 1..n (con n=100). Tampoco fue muy difícil.

class Integer
 def sum_square
   (1..self).inject(0) { |acum,n| acum + n * n }
 end
 def square_sum
   ((self * (self+1)) / 2) ** 2
 end
end

puts 100.square_sum - 100.sum_square

También por curiosidad, el resultado es 25164150.
El problema 7 es encontrar el primo número 10001. Para eso usé la criba que definí en el post anterior e iteré hasta el primo nro 10001.Acá va el código:

class OddPrimes
  def initialize
    @current = 1
    @primes = []
  end
  def next
    while not prime?(@current += 2)
    end
    @primes << @current
    @current
  end
  def prime?(n)
    i = 0
    p = 1
    while true
      break if i >= @primes.length
      p = @primes[i]
      break if p * p > n
      break if n % p == 0
      i += 1
    end
    return i >= @primes.length || p * p > n
  end
end

op = OddPrimes.new
p = 2
(2..10001).each {
  p = op.next
}

puts p

El primo que dio es el número 104743.
El problema 8 es medio rebuscado. Lo que me resultó más difícil es entender el enunciado. Te dan un número gigante y tenés que buscar cuáles son los 5 dígitos consecutivos que multiplicados dan el número más grande. Como en el problema 4 había implementado como obtener un dígito arbitrario y la cantidad de dígitos de un número, usé eso y resolví el asunto.

class Integer
 def digit(pos)
   (self / (10 ** pos)) % 10
 end
 def digit_count
   1 if self == 0
   dc = 0
   while self - (10 ** dc) > 0
     dc += 1
   end
   dc
 end
end

n = 7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450

pos = -1
prod = -1
(0..995).each do
 |p|
 candidate = n.digit(p) * n.digit(p+1) * n.digit(p+2) * n.digit(p+3) * n.digit(p+4)
 if candidate > prod
   pos = p
   prod = candidate
 end
end
puts "Digits: #{n.digit(pos)}, #{n.digit(pos+1)}, #{n.digit(pos+2)}, #{n.digit(pos+3)}, #{n.digit(pos+4)}"
puts "Position: #{pos}"
puts "Product: #{prod}"

El resultado que dio es:

Digits: 9, 7, 8, 9, 9
Position: 631
Product: 40824

El problema 9 consiste en buscar número a,b,c tal que son enteros a+b+c=1000 y a^2+b^2=c^2 (teorema de pitágoras para triangulos rectos). Para hacer eso, busqué una tripleta (a,b,c) tal que la suma divida a 1000 y después multipliqué cada número. La verdad es que este problema me costó un ratito. Acá va el código.

#Find a triplet that fits the pitagoras formula and its components divide 1000
def primogenial_triplet
 (3..100).each do
   |c|
   (2...c).each do
     |b|
     (1...b).each do
       |a|
       return [a,b,c] if a ** 2 + b ** 2 == c ** 2 and 1000 % (a+b+c) == 0
     end
   end
 end
end

tr = primogenial_triplet
factor = 1000 / (tr[0] + tr[1] + tr[2])
puts tr.map {|x| x * factor}

Los a,b y c que encontré son: 200, 375 y 425 respectivamente.
El problema 10 es el más interesante hasta ahora. El mismo consiste en sumar los números primos menores a 2000000. Primero usé el generador de primos que tenía, y lo implementé, pero tardó más de un minuto. El código es:

class OddPrimes
  def initialize
    @current = 1
    @primes = []
  end
  def next
    while not prime?(@current += 2)
    end
    @primes << @current
    @current
  end
  def prime?(n)
    i = 0
    p = 1
    while true
      break if i >= @primes.length
      p = @primes[i]
      break if p * p > n
      break if n % p == 0
      i += 1
    end
    return i >= @primes.length || p * p > n
  end
end

op = OddPrimes.new
sum = 2
while ( (p = op.next) < 2000000 )
  sum += p
end

puts sum

Pero me quedé enojado porque tardaba mucho, así que googlié un toque y encontré este post que mostraba otra forma de generar números primos. Y lo implementé. La idea es ir marcando todos los múltiplos (menores a un número dado) de los números primos que voy encontrando para encontrar los primos sin hacer divisiones. Y anduvo más rápido. Igualmente, hay que notar que gasta bastante más memoria que la versión anterior. Así que tiene un trade-off distinto entre memoria y tiempo de procesamiento. El código está acá:

MAX = 2000000

class OddPrimes
  def initialize(max)
    @max = max
    @prime_matrix = [false,true] * ((max / 2) + 1)
    @prime_matrix[1] = false
    @current = 1
  end
  def next
    while not prime?(@current += 2)
      throw :max_reached if @current >= @max
    end
    mark
    @current
  end

  def mark
    i = @current
    step = @current * 2
    while (i<@max)
      @prime_matrix[i] = false
      i += step
    end
  end
  
  def prime?(n)
    @prime_matrix[n]
  end
end

op = OddPrimes.new(MAX)
sum = 2
catch :max_reached do
  while ( (p = op.next) < MAX )
    sum += p
  end
end

puts sum

Esta solución corrió en 6 segundos:

$ time ruby euler10.rb
142913828922

real    0m6.179s
user    0m5.780s
sys     0m0.356s

Voy a tratar de seguir resolviendo los problemas del proyecto Euler, así que sigan sintonizados.
Happy hacking,
Aureliano.

Proyecto Euler - Primeros 4 problemas resueltos en Ruby

Mirando el blog de xkcd encontré un site donde postean un montón de problemas "matematicosos" para ser resueltos mediante programas de computadora que se llama proyecto Euler. Así que me copé, me puse a resolverlos e hice los primeros 4.
El primero es calcular la suma de los múltiplos de 3 o 5 menores a 1000, que lo saqué con un one-liner en ruby:

irb(main):006:0> (1...1000).select {|x| x % 3 == 0 || x % 5 == 0}.inject(0) {|sum,num| sum + num }
=> 233168

El segundo es calcular la suma de los números de fibonacci pares menores a 4000000. Este también lo hice en el irb, pero quizás debería haberlo escrito en un archivo. Lo que escribí en el irb es:

irb(main):007:0> class Fib
irb(main):008:1>   def initialize()
irb(main):009:2>     @a = 0
irb(main):010:2>     @b = 1
irb(main):011:2>   end
irb(main):012:1>   def next()
irb(main):013:2>     @a, @b = @b, @a+@b
irb(main):014:2>     @b
irb(main):015:2>   end
irb(main):016:1> end
irb(main):027:0> sum = 0
=> 0
irb(main):028:0> f = Fib.new
=> #
irb(main):029:0> while (n = f.next) <= 4000000 irb(main):030:1>   sum += n if n% 2 == 0
irb(main):031:1> end
=> nil
irb(main):032:0> sum
=> 4613732

O sea, la suma me dio 4613732, espero no haberme equivocado.
El tercer problema es encontrar el factor primo más grande de un número gigante (n=600851475143) . En este ya me puse a escribirlo en un archivo, porque me llevó más de 2 minutos. Lo que hice fue programar una criba para generar los números primos e ir dividiendo el n por los primos hasta que quede 1. Entonces el último primo por el que dividí es el factor primo más grande. El código en Ruby es así:

class OddPrimes
  def initialize
    @current = 1
    @primes = []
  end
  def next
    while not prime?(@current += 2)
    end
    @primes << @current
    @current
  end
  def prime?(n)
    i = 0
    p = 1
    while true
      break if i >= @primes.length
      p = @primes[i]
      break if p * p > n
      break if n % p == 0
      i += 1
    end
    return i >= @primes.length || p * p > n
  end
end

n = 600851475143
max_p = 1
op = OddPrimes.new
while n>1
  max_p = op.next
  while n % max_p == 0
    n /= max_p
  end
end

puts max_p

Según mi código, el factor primo más grande es el 6857.
Y, por último porque me tengo que ir a dormir, resolví el cuarto problema. El mismo consiste en calcular el número "capicúa" más grande que resulta de multiplicar 2 números de hasta 3 dígitos. El código es medio bestia, y fue la primera vez que el resultado no se sintió "instantáneo" (tardó como 2 segundos). Pero calculó el resultado. La idea del mismo es trivial. Probar todas las posibles multiplicaciones (que son como 500000) y fijarse si el resultado es capicúa y más grande que el número más grande encontrado. El código en ruby es:

class Numeric
def digit(pos)
 (self / (10 ** pos)) % 10
end
def digit_count
 1 if self == 0
 dc = 0
 while self - (10 ** dc) > 0
   dc += 1
 end
 dc
end
def palindromic
 digit_count = self.digit_count
 (0...(digit_count / 2)).each do
   |pos|
   return false if self.digit(pos) != self.digit(digit_count - pos - 1)
 end
 return true
end
end

lp = 0
f1, f2 = 0,0
(1..999).each { |x| (1..x).each { |y|
candidate = x * y
if candidate > lp and candidate.palindromic
 lp = candidate
 f1 = x
 f2 = y
end
}}
puts "Largest Palindromic: #{lp}"
puts "Factors: #{f1}, #{f2}"

El resultado que dio es:

Largest Palindromic: 906609
Factors: 993, 913

Estoy seguro que se puede optimizar "bocha" este código.

Bueno, me voy a dormir.
Espero escribir próximamente más problemas resueltos del proyecto Euler.
Happy hacking,
Aureliano.

Jugando con un proxy HTTP

El proxy transparente de Telefónica está andando mal y trae versiones viejas de un montón de páginas. Así que estuve pensando la forma de forzarlo a que traiga la última versión. Lo hablé con algunos compañeros de laburo, y lo que me sugirieron es que instale un proxy que agregue headers que fuercen el no-cacheo de las páginas. En particular, sugirieron que instalara privoxy y lo configurara con los headers que quiero agregar.
Pero, ¿para que voy a hacer algo rápida y fácilmente si me puedo meter en un quilombito? El mismísimo whytheluckystiff hizo mousehole, un proxy implementado en ruby puro. Pero mousehole está pensado para transformar las páginas a medida que van bajando, no para cambiar los headers a la ida. Así que tuve que toquetear un poquito.
Por lo que pude ver, mousehole tiene 3 capas. Una primera capa es el handler de mongrel que atiende los pedidos de http, la capa del medio es una capa que maneja los plug-ins del proxy (a los que llama apps) y una tercera capa son las apps propiamente dichas. Para agregar la funcionalidad de cambiar el request tuve que tocar estas 3 capas.
En el handler, agregué un lugar para interceptar la página antes de pedir al host la página. Este es el diff del svn:

Index: lib/mouseHole/proxyhandler.rb
===================================================================
--- lib/mouseHole/proxyhandler.rb       (revision 129)
+++ lib/mouseHole/proxyhandler.rb       (working copy)
@@ -46,6 +46,8 @@
       choose_header(reqh, header)
       set_via(header)

+      uri, header = @central.change_request(uri, header)
+
       http = Net::HTTP.new(env['server-name'], env['server-port'], @central.proxy_host, @central.proxy_port)
       http.open_timeout = 10
       http.read_timeout = 20

En la capa que maneja los plugins (que en el código se llama central) hice que cuando llegue un pedido, intente reescribir los headers en cada app. Este es el diff del svn:

Index: lib/mouseHole/central.rb
===================================================================
--- lib/mouseHole/central.rb    (revision 129)
+++ lib/mouseHole/central.rb    (working copy)
@@ -95,6 +95,13 @@
       end
     end

+    def change_request(uri, header)
+      @apps.values.each do |app|
+        uri, header = app.change_request(uri, header)
+      end
+      [uri, header]
+    end
+
     def rewrite(page, resin)
       apps = find_rewrites(page)
       return false if apps.empty?

Y por último, en la clase base de las apps hice que por default deje los headers y el URI original, así es todo retrocompatible (o casi). Acá está el diff del svn:

Index: lib/mouseHole/app.rb
===================================================================
--- lib/mouseHole/app.rb        (revision 129)
+++ lib/mouseHole/app.rb        (working copy)
@@ -58,6 +58,10 @@
       end
     end

+    def change_request(uri, header)
+      [uri, header]
+    end
+
     def do_rewrite(page)
       @document = page.document
       begin

Con todo esto andando, pude hacer mi cometido, que es hacer un proxy que le agregue el header "Cache-Control: no-cache" a los requests, para que Speedy no me de versiones viejas. El código de la app que hace esto quedó resimple:

class NoCache < MouseHole::App
  title "No Cache"
  namespace "aure"
  description %{
    Forces all the request to be non cached.
    Sets the Cache-Control header to no-cache.
  }
  version "0.1"

  def change_request(uri, header)
    header << ['Cache-Control', 'no-cache']
    [uri, header]
  end
end

Gracias Speedy y Telefónica por la inspiración y happy hacking,
Aureliano.

PD: si los headers no sirven, voy a cambiar el URI agregando parámetros aleatorios y listo, así que no me provoquen.

Conferencias al cuadrado

Esta semana estuve a full. En Buenos Aires hubo 2 conferencias de seguridad informática y tuve la suerte de poder ir a las 2.

El martes y miércoles estuve en BA-Con. Ahí conocí un montón de gente interesante y tuve la suerte de que las charlas también fueron re-interesantes.
Algunas charlas que me llamaron la atención y quería comentarles son:

• En la charla "WPA/WPA2: how long is it gonna make it" Cédric Blancher y Simon Maréchal contaron una forma interesante de generar passwords para brutforcear. La idea es que armás una cadena de markov donde cada caracter es un estado y la probabilidad de pasar de un estado "a" a un estado "b" es el porcentaje de las veces que viene una "b" después de una "a" de los passwords con los que generaste la cadena.
  
• La charla "All the Crap Aircrafts Receive and Send" fue divertida. Hendrik Scholz contó cómo se enteran los aeropuertos de los tiempos de arribo de los aviones (entre otras cosas). Y cómo hizo para reversear los mensajes (incluyendo ir con un receptor de radio en el auto al aeropuerto).
  
• En "LeakedOut: the Social Networks You Get Caught In", mi amigo y compañero de trabajo José Orlicki presentó sus avances de su trabajo de doctorado, donde estudia las redes sociales que se arman en los sitios Web 2.0 y sus implicancias en seguridad. A mi me pareció que fue la charla más original de las 2 conferencias.
• En "Pass-the-hash Toolkit for Windows" mi compañero de trabajo Hernán Ochoa mostró una vez más porqué es un groso en el mundo de la seguridad informática. Esta vez contó de su proyecto "Pass-the-hash" y su implementación en Windows. El proyecto sirve para afanar tokens de autenticación de la memoria de un Windows (!) y conectarse a otros hosts. La verdad, una masa. Si quieren usarlo, pueden bajarselo de acá.

El jueves y viernes tocó Ekoparty. Y también fue re-interesante. Les cuento que charlas me llamaron más la atención:

• En "Code injection on virtual machines", mi compañero de laburo Nicolás Economou se disfrazó de Neo y mostró como escribir memoria usada por un proceso de VM-Ware desde afuera para modificar el comportamiento de un programa corriendo adentro (!).
• En "Atancando RSA mediante un nuevo métodos de factorización de enteros", Hugo Scolnik mostró el laburo que están haciendo para tratar de romper RSA. La verdad, pareció re-interesante. Transformó el problema de factorización de un número de la forma p*q en un árbol de decisiones y muchas formas de podar el árbol. Y mostró como, si se pudiera elegir correctamente en ese árbol (cosa que todavía no hacen), la factorización del RSA640 tomaría un par de minutos en una Pentium 3.
• En "Smartphones (in)security" mis compañeros de laburos Alfredo Ortega y Nicolás Economou (que ya se había sacado el traje de Neo), mostraron cómo explotar un stack overflow en iPhone y Android. Fue una charla interesante y entretenida, donde también explicaron re-bien como funciona la técnica "return to libc" para escribir exploits cuándo la memoria que podemos sobreescribir no tiene derechos de ejecución.
• Y en "Debian's OpenSSL random number generator Bug" Luciano Bello y Maximiliano Bertacchini contaron los detalles técnicos y las consecuencias de comentar una línea de código para que el valgrind no se queje. Esa línea, hacía que la entropía del generador sea tomada solamente del nro. de proceso (o sea, que si repetís el número de proceso, generás los mismos números aleatorios) y cómo usar esto para hacer ataques.

Al final, después de una semana de conferencias quedé con la cabeza que explota de conocimientos nuevos, conocí un montón de gente interesante y tengo un muchas tarjetas personales (que nunca sé que hacer con ellas).

Happy hacking,
Aureliano.

Blog de Nicolás

Cómo les había contado en un post anterior, voy a ser papá. Y hoy, junto con Agus inauguramos su propio blog. Ahí vamos a ir poniendo todas las fotos, videos y etcéteras mientras sea un proyecto o un bebé.

Guerra con Telefónica

Hace un tiempo les conté que tuve problemas con Telefónica. Los problemas siguieron, y groso. En los últimos 3 meses estuve más de la mitad del tiempo sin teléfono ni ADSL. El jueves pasado, fui y pedí que me dieran un listado de incidencias impreso, al que se negaron. Pero me mostraron el registro de apertura y resolución de tickets. La verdad es que es una vergüenza. Cerraron un montón de tickets diciendo que había problemas en el consorcio pero a mi no me informaron cuál es el problema del consorcio.
Vivo en un edificio de menos de 10 años, los conductos centrales para cables de teléfono son de 20cmx20cm (o más), y el cableado de dentro del edificio lo pusieron ellos. Aparte nunca dijeron que parte del cableado del consorcio sería la que está rota y cuándo un técnico habló personalmente conmigo me dijo que el consorcio y el departamento no tienen ningún problema. En el medio de todos los tickets cerrados por "problemas en el cableado interno del consorcio" hubo uno que lo cerraron por otro motivo porque ya les daba vergüenza. Se ligó mi teléfono con un teléfono de otro edificio. ¿Cómo me enteré? Disqué 115, corté y aparte de sonar mi teléfono sonó en otro lado y atendieron, así que pude charlar con la persona con la que tenía ligado el teléfono. Así que llamé al 114 y lo avisé. Sino quizás a este ticket también lo hubieran cerrado como "problemas en el cableado interno del consorcio".

Bueno, abajo les dejo un detalle de los tickets, fechas de inicio y fin y sus resoluciones y les pregunto. ¿Saben cómo hacer para que les pongan una multa gigante?

• Nro. de ticket: 2008027000066336
• Inicio:28/6
• Fin:7/7
• Resolución: Cableado interno consorcio
• Comentarios: ¿No será que el problema está en otro lado?

• Nro. de ticket: 2008027000068188
• Inicio: 3/7
• Fin: 24/7
• Resolución: Cableado interno consorcio
• Comentarios: ¿No será que el problema está en otro lado?

• Nro. de ticket: 2008027000076656
• Inicio: 21/7
• Fin: 1/8
• Resolución: No permitió vigilancia
• Comentarios: Vienen en cualquier momento, ¿saben que tenemos cosas que hacer aparte de esperar a que vengan a arreglar el TE? No vinieron en los horarios de citas concertados

• Nro. de ticket: 2008027000080132
• Inicio: 29/7
• Fin: 21/8
• Resolución: Configuración ADSL
• Comentarios: Era hora que admitan que hay algún problema en su servicio, la configuración mala del ADSL genera interferencias en la línea (aparte de microcortes)
  

• Nro. de ticket: 2008027000083451
• Inicio: 7/8
• Fin: 21/8
• Resolución: Configuración ADSL
• Comentarios: Pasó más de una semana y seguía con los mismos problemas
  

• Nro. de ticket: 2008027000089423
• Inicio: 25/8
• Fin: 6/9
  
• Resolución: Cambio de bajada
• Comentarios: Al fin hacen algo, para algo pago el abono de mantenimiento

• Nro. de ticket: 2008027000094576
• Inicio: 10/9
• Fin: 17/9
• Resolución: Cableado interno consorcio
• Comentarios: Nadie tocó nada, ¿se rompe y arregla solo?

• Nro. de ticket: 2008027000098212
• Inicio: 22/9
• Fin: 24/9
• Resolución: Se regenera línea ADSL
• Comentarios: Parece que sigo con quilombo
  

¿Saben que tengo que hacer para que los multen? ¡Tuve tickets abiertos el 90% del tiempo de los últimos 3 meses!
Happy hacking,
Aureliano.

Inauguración quilmeña - El ibérico

Quería contarles que Guillermo, el primo de mi mujer, inauguró "El ibérico", una fiambrería-rotisería en Quilmes. Más especificamente en Brandsen e Hipólito Yrigoyen (sobre Hipólito Yrigoyen). Así que si vuelven a Quilmes después de un día de laburo/joda y no saben que comer, pueden pasar por ahí y comprarse un pollo al spiedo, o un buen jamón, un buen queso y pan, y para el postre, un dulce cordobés casero que está super-re-barato ($7 el kilo, aprovechen antes que se avive). También un buen vino y tienen todo resuelto. Y no se olviden de decir que van de parte mía. Y si son unos vagonetas, también pueden llamar por teléfono al 4253-7006 y hacer su pedido.
Happy hacking,
Aureliano.

¡Se reproducen!

Sí, quiero presentarles a nuestro primogénito. Esta es una imagen de la última ecografía (de cuando tenía 13 semanas de gestación). Vieron, aunque parezca increíble, ¡los geeks se reproducen!
¿Cuánto tardará en aprender a programar?

Ingenieros contra la naturaleza

Los ingenieros son grosos y le ponen el pecho a las balas. Y hacen cosas grosísimas. Un ejemplo es esta foto de un dique en Nueva Orleans, que esta vez si aguantaron el paso de un huracán. Groso lo que bancan, la foto es increíble (3 metros de agua con tormenta aguantados por una pared).



Si quieren, pueden ver la nota en clarín.

Jornadas Regionales de Software Libre

La semana pasada se hicieron en Buenos Aires las Jornadas Regionales de Software Libre. Las Jornadas fueron interesantes y tuve la oportunidad de charlar con un montón de gente y hacer mi presentación. Porque estoy a full con el laburo solo pude ir el jueves, que fue el día de mi charla de Rubygame como ya les había contado antes.
La charla salió medio medio porque tuve quilombos con el proyector :(. Después del ¡tercer proyector! logré que salga algo por la salida de VGA de mi notebook, pero solo booteando de un LiveCD. Por lo tanto, no pude mostrar mis jueguitos andando, pero si pude mostrar los slides que tenía preparados. Igual fue divertido, y espero poder presentar algo la próxima (que si puedo me llevo mi propio proyector y listo). Por último les dejo una foto de mi charla, que sacaron Gutes y Tenuki:


Happy hacking,
Aureliano.

Torre de Agua

Ayer al mediodía, que todavía estaba en Mar del Plata, fuimos con Agus a visitar la Torre de Agua de Mar del Plata. Antes de ir estuvimos buscando el horario de apertura y cierre de la torre y no lo encontramos por ningún lado. Así que les paso horarios y coordenadas.
¿Cuándo? Días hábiles de 8:00 a 14:45hs.
¿Dónde? Falucho y Mendoza.
Si van, van a ver una vista panorámica de Mar del Plata, mirando desde arriba de la torre. Y abajo hay un museíto que no tiene demasiado interés. Pero la vista está bárbara.
Happy hacking,
Aureliano.

"Vacaciones"

Esta semana estoy paseando por MDQ. Pero siempre algo de laburo tengo encima. Aparte de estar haciendo un trabajo práctico para mi doctorado, mañana miércoles a las 19hs nos encontramos con algunos de los pibes de Ruby Argentina en Piazza, que queda en Alem y la costa, y haremos un "PizzaConf" (o sea, nos juntamos a hablar de cosas de Ruby y comer pizza).
Todo rubista que quiera apropicuarse por allá será bienvenido. Si quieren traigan su notebook o alguna idea de algo que quieran presentar (hasta 1/2 hora, desde 1/2 segundo), o si quieren no traigan nada y vengan y listo. Si pinta, supongo que haré un "preview" de la presentación sobre RubyGame que voy a hacer en las Jornadas Regionales de Software Libre.
Happy hacking,
Aureliano.

Cobos votó "no"

Update: Efectivamente un moderador sacó el comentario. Suerte que lo agarré a tiempo. Si quieren saquen sus propias conclusiones sobre porqué alguien quitaría un comentario como este.

A veces, y solo a veces, los foros de La Nación tienen algunas joyas increíbles. En particular, el mensaje #511 de esta nota es divertido. Acá abajo lo pongo textual (antes que lo agarre un moderador y lo saque):

COBOS POMPOSO CON PONCHO. COBOS JOCOSO. COMO TROMPO RODO POR OTROS HOYOS. COMO BOROCOTO, TROCO VOTO. COMO ORTODOXO DOCTOR, VOTO NO. VOTO CON LOS OJOS ROJOS, CON SOLLOZOS, CON SOPOR, MONOLOGO SOLO POR NO. ¿ VOTO SOLO POR LOS POROTOS ? ¿ VOTO POR SPONSOR CON FRONDOSO OBOLO ? PROMOTOR CON BOLSOS CON ORO, DOTO CON VOLVO ? COLOCO MONTOS GROSOS POR BOSTON, OSLO, TORONTO O LONDON ? COMO SOMOS !!! NO LO SOPORTO... BOROCOTO: ZORRO DOLOSO, COBOS: BOCHO HONROSO !!! FOR GOD !!! ¿ SOMOS TODOS GROSSOS ? NO. SOMOS ZONZOS, SOMOS LOCOS, SOMOS BOCHORNOSOS COMO COPPOLO. SOCORRO !!!

Mis charlas en las Jornadas Regionales de Software Libre

Hola,
Estoy muy contento de contarles que voy a participar en un par de charlas de las jornadas.
La primera es una charla introductoria a rubygame. Usando como excusa los jueguitos sobre los que estuve posteando a principio de año por acá, voy a pasar por las cosas básicas de la biblioteca. Esencialmente sprites y manejo de eventos.
La otra es una charla de mi amigo Matías Brutti sobre metaprogramación en Ruby, en la que le voy a dar una mano. Todavía no hablamos de como la vamos a organizar pero supongo que tendrá contenido parecido al del post del tema que hice acá a mediados del año pasado.
Las jornadas son el 20, 21 y 22 de agosto (sí, en 2 semanas). Mis 2 charlas son el 21 de agosto. La de Rubygame es a las 10AM (sí, bastante tempranelli) y la de metaprogramación a las 4PM. Las jornadas se hacen en la Universidad de Belgrano (Zabala 1837, Ciudad Autónoma de Buenos Aires, Argentina). Tienen que anotarse antes para poder ir. Hay más información en la página de las jornadas.
Los espero.
Happy hacking,
Aureliano.

El día que Stallman apareció en infobae

Cada vez más, el software libre se hace mainstream. Y hoy pasó una vez más. Hoy entré a infobae.com y, sorpresa, sorpresa, al lado de los escándalos de la ex-novia de Ronaldo estaba una nota sobre ¡Richard Stallman! Acá les paso el link. ¡Y encima Stallman está peinado!

Hasta el premio Nobel de la Paz no para.

Happy hacking,
Aureliano.

Criptografía cuántica - explicación simple.

Ayer a la tarde vino al laburo Andrés Rieznik a dar una charla sobre criptografía cuántica. Andrés es doctor en física, es especialista en fibras ópticas y actualmente está haciendo un post-doctorado en el ITBA (sí, donde yo estoy haciendo el doctorado). Y Andrés también iba a la división de al lado en la secundaria.
Bueno, volviendo al tema de la criptografía cuántica, primero nos explicó en que fenómenos de la física cuántica está basada.

Polarización, fotones y otras cosas que solo los físicos entienden

Como todos sabemos, la luz a veces es una onda. Cuando hace de onda, la onda puede oscilar en cualquier ángulo (por ejemplo: verticalmente, horizontalmente o diagonalmente). Y cuando pasa a través de un polarizador queda oscilando en la dirección que el polarizador la deja. Y si después ponemos otro a 90 grados, no pasa nada. Y más aún, si ponemos el segundo polarizador a 45 grados sale un cuarto de la luz original (se queda la mitad en cada polarizador) ¡polarizada en el ángulo del segundo polarizador!
Pero también, la luz a veces es muchas partículas. Cuándo actúa como partículas, decimos que está compuesta por fotones. Entonces ¿qué pasa cuando pasa un solo fotón por un polarizador?.
Según entendí de lo que dijo Andrés, los fotones tienen un ángulo de oscilación. Y pasan o no por un polarizador en función de ese ángulo. En particular, si el polarizador está perfectamente "alineado" con la oscilación del fotón pasa siempre y si está perfectamente cruzado con el fotón no pasa nunca. ¿Y qué pasa si está a 45 grados? Entonces pasa la mitad de las veces y, cuando pasa, cambia el ángulo de su oscilación al del polarizador por el que pasó.
Bueno, usando todo lo que está arriba, hace ya 24 años a unos cráneos se les ocurrió una idea para que 2 partes (digamos, para mantener las costumbres, Alice y Bob) compartan un "stream" de números al azar. O sea, que los 2 sepan los mismos números, pero que estos números no están definidos de antemano. Para los que sepan cripto, el resultado es muy parecido a Diffie-Hellman pero se llega por caminos muy distintos. A ese tipo de algoritmos se los llama de "intercambio secreto de claves". El primer algoritmo que hicieron se llama BB84 (son unos cráneos pero tienen menos onda para los nombres que un fotón).

El BB84

En el algoritmo BB84, cada número lo manda como un único fotón polarizado en un ángulo de 0, 45, 90 o 135 grados. 0 grados se corresponde a un 0 en base A, 45 grados a un 0 en base B, 90 grados a un 1 en base A y 135 grados a un 1 en base b.

El algoritmo consiste en lo siguiente:
Alice elige una base (entre A y B) y un nro (entre 0 y 1) y manda un fotón polarizado en el ángulo correspondiente. Bob elige una base al azar y detecta (en esa base) el número. Si los 2 eligieron la misma base, los 2 conocen el mismo número, sino hay un 50% de chances de que Bob tenga un número distinto del que tiene Alice. Este procedimiento se repite n veces.
Cuando Alice termina de mandar cada uno de los bits, Alice manda por un canal normal (no cuántico) que bases usó para mandar cada bit. Bob, con esa información, le dice cuáles de los bits leyó en la misma base que Alice transmitió (van a ser aproximadamente la mitad).
Para ver que efectivamente nadie cambió los bits en el camino se eligen algunos de los bits efectivamente transmitidos y se los manda por un canal no cuántico para verificar que la transmisión fue correcta.
Después de esto, los bits efectivamente transmitidos que no se publicaron son los que forman la clave conocida por Alice y Bob.

¿Y Eve?

¿Qué pasa si Eve interfiere un fotón? Bueno esta es LA gracia de todo el asunto. En mecánica cuántica existe una cosa que se llama "principio de incertidumbre" (lo siento, va sin link porque no me gustó el artículo de wikipedia). El principio de incertidumbre dice que es imposible obtener una medida en una partícula sin modificarla en otra aledaña. Por ejemplo, si medís la velocidad de una partícula modificás su posición, haciendo imposible saber la posición original.
Bueno, el número (0 o 1) y la base (A o B) que representa el ángulo de polarización de un fotón es como saber la posición y la velocidad. Si medís el número, como tiene que pasar por un polarizador, cambiás potencialmente la base del fotón (el 50% de los casos). O sea, que si Eve escucha un fotón, el 50% de los casos le cambia la base. De ese 50%, el 50% de los casos Bob va a escuchar el número incorrecto. Por lo tanto, en la verificación que se hace al final del algoritmo van a detectar que el 25% de los bits están mal. Entonces se detecta a Eve y no se usa esa clave para transmitir info segura.

Unas cositas más

El BB84 no es el único algoritmo conocido, hay variaciones, pero todas están basados en que para medir si un fotón pasa o no por un polarizador hay que cambiarle el ángulo de polarización.
Por último, las cosas que estén mal explicadas son culpa mía y las que estén bien culpa de Andres.

Happy hacking,
Aureliano.

Problemas con el DNS de speedy

Update: Gracias a Manuel por llevar a mi atención esta vulnerabilidad del diseño del DNS. No está confirmado, pero es altamente probable que la inestabilidad de los servers de Speedy tengan que ver con esto. Les sugiero que como medida de seguridad usen los servidores DNSs que están mencionados abajo aunque tengan otro proveedor de internet, al menos por un tiempo. Estos servers aparentemente no son vulnerables.

Desde ayer que el DNS de speedy está inestable. Hoy llamé al soporte técnico y me lo confirmaron. Como no me dieron ningún servidor de DNS alternativo, me conecté a google x ip (estaba haciendoles ping para hacer troubleshooting) y leí algunos caches de páginas. Ahí encontré esta página donde sugieren usar Open DNS.

Así que configuré en mi router los servidores de nombres que dice ahí (son 208.67.222.222 y 208.67.220.220) y ahora puedo navegar nuevamente.

Happy hacking,
Aureliano.

Cómo hacer que Telefónica arregle tu teléfono

Update: Incluye segundo corte de teléfono.

Según mi experiencia en reparaciones de mi línea telefónica, este es el algoritmo apropiado para lograr reparaciones medianamente rápidas:

1. Llamar al 114 (te atiende el contestador automático)
2. Llamar al 112. Nadie atiende.
   
3. Llamar al 114 de nuevo. El contestador automático te informa que tu teléfono será reparado "en los plazos establecidos".
4. Llamar al 112. Nadie atiende
5. Llamar al 114 de nuevo. Poner otro número de teléfono. Te atiende el operador.
6. El operador te corta antes de admitir que te está boludeando porque no puede abrir el ticket de la reparación del teléfono.
7. Llamar al 112. Nadie atiende
8. Llamar de nuevo al 114, poner de nuevo un número equivocado. Quejarse que te cortaron en la mitad de la queja anterior. Te explican que en realidad no pueden abrir tu ticket (operador buena onda, probablemente empezó a trabajar hoy).
9. Llamar al 112. Atienden (¡milagro!). Abrís un ticket quejandote de que no hay plazos por la reparación y porque te cortaron cuando llamaste al 114.
10. ????????????????????????????????
11. A los 10' de la última llamada arreglan la línea.
12. ????????????????????????????????
13. A las 12 horas se vuelve a quedar sin tono.
14. Habla mi suegra con Telefónica, dicen que vienen mañana antes de las 10 AM. Alegan que hay un problema en mi casa (¡pero pusieron a andar el teléfono 12 horas sin venir!).
    
15. Me dejaron plantado. Segundo fin de semana sin teléfono ni internet.
16. Llaman a mi suegra, que no está, y le dicen que van a venir cuando no haya nadie en el depto.
17. Llamo a reparaciones de larga distancia de telefónica (al servicio técnico habitual no me puedo comunicar porque no te atienden cuando hay un arreglo en curso, seguro que esto es antirreglamentario). Por suerte toman los datos del teléfono de la oficina (o eso me hace creer la operadora.
    
18. ?????????????????????????????????
19. Llego a casa a la noche y anda todo (vamos a ver con cuanto tiempo).
    

Conclusión: Con Telefónica todo mal. Igual, llamen al 112 y rompan las bolas. Puntos extra si van o se quejan en Defensa del Consumidor.

Aureliano.

PD para la gente de codear: En cuanto tenga tiempo quiero hacer un post sobre mónadas en Haskell. Tenganme paciencia.

Busco hogar para Amón

Estoy buscandole un nuevo hogar a Amón, mi gato. Es macho, super-juguetón, tiene 2 años y está castrado. Vivió siempre en depto, así que está acostumbrado a la compañía humana. A quién le interese ser su nuevo "papá" o "mamá" por favor comuníquese x acá o a aurelianocalvo at gmail.com (cambiando at por @).

Acá abajo pongo una foto así se van encariñando.



Muchas gracias,
Aureliano.

Grandes ideas

Odio cuando se me ocurren ideas que creo "geniales" y "únicas" para después descubrir que alguien ya lo hizo antes. Esto me pasa todo el tiempo :(. Y hoy pasó de nuevo.
Cuando volvía caminando del fútbol del domingo al medio día se me ocurrió "estaría buenísima una página web que sirva para organizar los partidos de fútbol". Los quilombos de los mails solucionados. Nadie haría mucho laburo (después de todo, la página haría sola toda la coordinación). Así que me puse a hacerla, y mientras la hago chequeo el correo y veo otra página web que es para esto.
Bueno, parece que voy a tener más tiempo para estudiar para el doctorado.

Happy hacking,
Aureliano.

El lock-out

A veces uno trata de explicar cómo son las cosas, pero viene un humorista y deja todo claro.

Estudio de noche y Google Analytics

Ayer a la noche (u hoy a la madrugada, en función de lo que quieran pensar) fui como invitado al programa Estudio de Noche en la Radio de la Ciudad. Ahí estuvimos hablando con mi amigo Gustavo Fernandez Walker(el conductor) y mi amigo Martín Gonzalez(el otro invitado) sobre varias cosas, pero principalmente sobre el impacto de la Internet sobre la forma de generar eso a los que los abogados llaman propiedad intelectual. En particular estuvimos hablando del impacto en obras artísticas (y aún más en particular, de obras musicales). También tocamos tangencialmente el tema de los wikis y del desarrollo de software libre. Me divertí haciendo radio, así que probablemente vaya como invitado alguna otra vez.
También le mostré a Gustavo Google Analytics, que le gustó y lo puso en el blog del programa. Gustavo es filósofo y estas instrucciones le sirvieron, así que supongo que le servirán a cualquiera que tenga un blog en blogspot (y cambiandolas un poquito, cualquier página). Acá pego las instrucciones textuales:

Tenés que ir al panel de tu blog -> diseño -> Añadir un elemento de
página -> HTML/Javascript
y poner adentro de eso el cacho de código que te dicen que pongas en
google analytics. En mi caso es:
<script src="http://www.google-analytics.com/urchin.js" type="text/javascript">
</script>
<script type="text/javascript">
_uacct = "ACA VA UN CODIGO TUYO";
urchinTracker();
</script>
Seguramente debe ser algo parecido en el tuyo. Una vez que tenés eso
agregado, cada vez que alguien se conecte a tu blog se va a bajar ese
código, que es el que hace que google pueda saber quienes se conectan
a tu página (así es en la mía). Es solo copiar el cacho de código en
blog como dice arriba y activar el trackeo en google (si no me acuerdo
mal).

Happy hacking,
Aureliano.

Buscando hosting para mis proyectos personales

Hola a tod@s,
Estoy buscando un hosting para mi. La idea es poner ahí las cosas que haga para el doctorado (así tengo acceso desde todos lados, versionado y un backup en otro lado) y algún que otro prototipo de página web que se me ocurra (tenía algunos pensados que no hice porque no tenía dónde ponerlos).

Mis requerimientos principales son que tenga svn por ssh y https (para lo del doctorado) y que pueda correr ruby para hacer la página (y seguramente alguna base de datos).

También estaría bueno acceso por ssh para poder tocar todo, que sea barato y que si me paso del ancho de banda diario/ semanal/ mensual corten el site y me manden un mail para ver que hacer (para evitar la quiebra por slashdot). No creo que, al menos al principio, tenga mucho tráfico.

Por favor, cuéntenme cómo les fue con sus proveedores de hosting. Escucho sugerencias.

Happy hacking,
Aureliano.

Wireless@home

Update: Más configuración por seguridad

Hoy configuré el modem ADSL/router/access point wireless (AKA: "el coso wireless") que me compré en la semana y lo hice andar completo (wireless con WAP2). Es un hermoso ZyXEL PRESTIGE 660R-61C.
Ahora les cuento que cosas tuve que hacer para hacerlo hacer andar.

Paso 1: conexión a speedy

Conecté una notebook con fluxbuntu al "coso wireless" con el cable ethernet que viene en la caja y enchufé el cable de teléfono (que también viene en la caja) entre el coso y la boca de teléfono. Configuré eth0 para que esté en 192.168.1.23 (creo que casi cualquier IP en la red 192.168.1.x debe andar) y me dirigí con un browser a 192.168.1.1. Por suerte le pegué (de re-pedo) y entré al menú de configuración del coso vía web.
Intenté setear de una la conexión pero no funcó :(. ¿Por qué? Los seteos de VPI y VCI correctos para speedy (8 y 35 respectivamente) no los aceptaba. Después de un rato de googleo, encontré la página de speedy donde explica como configurar el coso wireless. Lo único que hice distinto es que cómo ya había cambiado el password de administración desde la parte web, puse mi password nuevo. Seguí las instrucciones, setié como name servers a200.51.211.7 y 200.51.212.7 y ¡se conectó a speedy!

Paso 2: Compartir la conexión entre varias PCs

Con esto andando, el siguiente paso fue compartir la conexión entre 2 PCs. Esto fue re-fácil. Configuré mis 2 notebooks x DHCP y las enchufé al coso wireless con sendos cables ethernet. Una vez que las PCs estuvieron andando, ya tenía conexión a internet :D

Paso 3: El coso wireless es wireless (y se supone que yo sé de seguridad informática)

Bueno, esto ya estaba andando. Entonces me puse a configurar el acceso wireless. En cuanto miré, algún vecino "extra rápido" ya se había conectado a mi coso wireless y estaba leecheando internet. Así que empecé a cerrarlo. Mirando rápido el menú me pareció que había solo WEP, y "this is unacceptable" para un investigador en seguridad informática como yo (chiste). Así que apagué el wireless para que no leecheen más y empecé a mirar la configuración. Al final encontré la parte de WAP, que está en otro menú (parece que la amigabilidad no es parte de los objetivos de diseño del menú administrativo por web del coso wireless). Y empecé a probar.
Para hacer andar la parte wireless tuve un desafío extra, que es que lo hice andar en un Kubuntu Hardy (8.04). Por suerte, cuando compré mi notebook tuve la delicadeza de comprar una placa Intel, por lo que se me hizo más fácil. Después de varias vueltas descubrí que lo mejor era configurar el coso wireless en WPA2 con PSK (pre-shared key). Y solo queda explicar que hice para hacer que ande el Kubuntu. Probé un montón de cosas que no andaban hasta que encontré por internet (no tengo el link acá) que a veces reinstalando algunos paquetes la integración de las placas wireless. Así que hice

sudo aptitude reinstall knetworkmanager wpasupplicant network-manager

y santo remedio. Cargué el KNetwork Manager y cliquié el botón derecho, me conecté a mi red, puse el password que había configurado en el párrafo anterior y anduvo todo joya.

Paso 4: Ajustes finales

Por último, quiero seguir pudiendo conectarme a bit torrent bien para "bajar ISOs de Linux". Así que configuré que la MAC de mi notebook tenga IP fija (está en la parte de LAN del menú avanzado) y forwardié los puertos correspondientes (TCP y UDP) que tengo configurados en el KTorrent.
Y para que sea más seguro (mirando los ataques que postulan en GNU Citizen) le configuré distinto el SNMP. Me conecte x telnet al coso y cambié las opciones del menú 22, que quedó algo así:

SNMP:
Get Community= [passwd nuevo]
Set Community= [otro passwd nuevo]
Trusted Host= 0.0.0.0
Trap:
  Community= [y otro pass más]
  Destination= 0.0.0.0

En una mirada rápida, me pareció que el resto de los ataques requieren que el atacante esté conectado en la red interna, así que los dejo para después (supongo que requerirán un cambio de firmware).

Así llegué a la configuración que quería y me dediqué a escribir este post.
Happy hacking,
Aureliano.

El último pelo

Este hilarante blog habla de los calvos. Sus problemas y soluciones. Envidias y resentimientos. Gracias y tristezas. Recomiendo ampliamente a este blog, que es el único que conozco que tiene su propia canción. En fin, tómense unos minutos y ríanse un rato. Yo, como buen calvo que soy, lo recomiendo.

Happy hacking,
Aureliano.

Load balancer minimalista en ruby (parte 2)

En el post anterior mostré un load balancer que implementé en ruby. Ahora le agregué algo de manejo de errores y algo de fail-over para que sea más estable.

Este es el código nuevo:

#!/usr/bin/env ruby
require 'socket'

def usage
  puts "Very simple balancer"
  puts "balancer.rb port host1:port1 [host2:port2 ....]"
  exit
end

def build_targets(argv)
  argv.map do
    |param|
    result = param.split(":")
    result[1] = result[1].to_i
    result
  end
end

class Balancer
  def initialize(port, *targets)
    @descriptors = []
    @next_step = {}
    
    @serverSocket = TCPServer.new( "", port )
    @serverSocket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
    puts("Balancer started on port #{port}")
    
    @descriptors << @serverSocket
    
    @targets = targets
    @current_out = 0
  end
  
  def next_out
    out_socket = nil
    until out_socket
      begin
        @current_out = (@current_out + 1) % @targets.length
        descr = @targets[@current_out]
        out_socket = TCPSocket.new(descr[0], descr[1])
      rescue
        # do nothing on purpose
      end
    end
    out_socket
  end
  
  def accept_new_connection
    
    incoming = @serverSocket.accept
    outgoing = next_out
    
    @next_step[incoming] = outgoing
    @next_step[outgoing] = incoming
    
    @descriptors += [ incoming, outgoing ]
  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|
      begin
        s.close
      rescue Object => e
        puts "Error closing socket: #{e.inspect}"
      end
      @descriptors.delete(s)
      @next_step.delete(s)
    end
  end
  
  def run
    loop do
      connections = select( @descriptors )
      if connections
        connections[0].each do
          |sock|
          if sock == @serverSocket then
            accept_new_connection
          else
            begin            
              if sock.eof? then
                finish_connection(sock)              
              else
                propagate(sock)
              end
            rescue
              finish_connection(sock)
            end
          end
        end
      end
    end
  end
end

trap("SIGINT") do
  exit
end

usage if ARGV.length < 2 
port = ARGV.shift.to_i
targets = build_targets(ARGV)

Balancer.new(port, *targets).run

Me parece que ahora pueden llegar a usarlo.

Happy hacking,
Aureliano.

Load balancer minimalista en ruby

Update: Puse la versión más nueva en este post.

Ayer estuve inspirado y dediqué un poquito de mi tiempo a aprender un poco más sobre cómo manejar sockets. Hacía mucho tiempo que no programaba sockets en bajo nivel y nunca había necesitado usar select para manejar muchos al mismo tiempo. De hecho, la última vez que tuve que hacer algo parecido a un server que acepte muchas conexiones TCP lo hice en java 1.3, y en java 1.3 no hay select (agregaron algo parecido en java.nio, que apareció después).
Así que puse manos a la obra e hice un minicloncito de un load balancer en ruby.
Por supuesto que no hice todo. En particular, me comí el manejo de errores. Pero si hace round robin de conexiones y tiene menos de 100 líneas de código, lo que creo que lo hace un buen ejemplo de juguete sobre como manejar sockets en ruby.
Bueno, basta de cháchara, acá va el código completo:

#!/usr/bin/env ruby
require 'socket'

def usage
 puts "Very simple balancer"
 puts "balancer.rb port host1:port1 [host2:port2 ....]"
 exit
end

def build_targets(argv)
 argv.map do
   |param|
   result = param.split(":")
   result[1] = result[1].to_i
   result
 end
end

class Balancer
 def initialize(port, *targets)
   @descriptors = []
   @next_step = {}

   @serverSocket = TCPServer.new( "", port )
   @serverSocket.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
   puts("Balancer started on port #{port}")

   @descriptors << @serverSocket

   @targets = targets
   @current_out = 0
 end

 def next_out
   @current_out = (@current_out + 1) % @targets.length
   @targets[@current_out]
 end

 def accept_new_connection
   out_descriptor = next_out

   incoming = @serverSocket.accept
   outgoing = TCPSocket.new(out_descriptor[0], out_descriptor[1])

   @next_step[incoming] = outgoing
   @next_step[outgoing] = incoming

   @descriptors += [ incoming, outgoing ]
 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|
     s.close
     @descriptors.delete(s)
     @next_step.delete(s)
   end
 end

 def run
   loop do
     connections = select( @descriptors )
     if connections
       connections[0].each do
         |sock|
         if sock == @serverSocket then
           accept_new_connection
         else
           if sock.eof? then
             finish_connection(sock)
           else
             propagate(sock)
           end
         end
       end
     end
   end
 end
end

trap("SIGINT") do
 exit
end

usage if ARGV.length < 2
port = ARGV.shift.to_i
targets = build_targets(ARGV)

Balancer.new(port, *targets).run

Para usarlo, copien todo el codigo a un archivo (como balancer.rb) y fijense en el cartel que explica los parámetros. El primer parámetro es el puerto donde escucha y los otros son pares host:port a los que tiene que conectarse alternativamente.

Bueno, eso es todo por ahora.

Happy hacking,
Aureliano.

Reconstrucción del ligamento cruzado anterior de la rodilla derecha - Epílogo

Como estuve contando hace un tiempo por acá hace un poco más de un año y medio me operaron para reconstruir el ligamento cruzado anterior de mi rodilla derecha, que fue obliterado en una de mis tantas caídas que tengo cuando esquío (en realidad fue la última). Ahora dejé de esquiar, más que nada por falta de $$$$, y me reincorporé al resto de las actividades usuales de mi vida (incluyendo volver a jugar al "fútbol" los domingos).

Aunque hace muuuucho tiempo que no escribo nada de esto, sigue habiendo gente que se interesa en estos posts de mi blog y, extrañamente, si buscan reconstrucción de ligamentos en google este blog aparece en la primera hoja, me pareció pertinente contarles como fue mi recuperación y como llegué a estar 100% activo deportivamente nuevamente.

Así que les cuento.

Septiembre 2006

Me operaron, pueden ver los detalles en este blog.

Octubre 2006-Marzo 2007

A los 20 días de la operación (aprox) el traumatólogo me dijo "ahora tenés que hacer rehabilitación". La rehabilitación es larga (dura unos 6 meses) y laboriosa (hay que ir 3 veces x semana como 2 horas) pero si hacen las cosas bien lo más probable es que queden bien. Así que me puse las pilas.
Al principio era la típica kinesiología que pensás que es medio al dope donde te ponen esos aparatos que hacen "magnetoterapia", que son como unos cilindros por donde pasas la pierna y están enchufados a un aparato con un timer, que hace ruido cuando termina. También te torturan un poquito haciendo estimulación eléctrica de los cuádriceps de la pierna operada. Media hora y despachás.
A las 2 semanas decidieron que era hora que hiciera pesas y estuve haciendo diversos ejercicios pero solo con la pierna rota, previa magnetoterapia. Todo el chiste me llevaba como 2 horas cada vez, un embole. Y encima en el gimnasio no había una mina que estuviera buena. Solamente un montón de tipos recuperandose de roturas de ligamento cruzado anterior y viejos con dolencias variadas :(.
Mientras pasaba el tiempo me fueron agregando ejercicios y subiendo el peso de los mismos hasta que idearon otra forma de torturarme: estimulación eléctrica del cuádriceps mientras hacía pesas.

¡A la mierda!

Eso si que es feo. Aparte te tiran voltajes grosos. La máquina la usaban entre ¡80 y 120 volts! (posta) y parecía que me iban a electrocutar toda la pierna. Pero cumplió su objetivo.
Al final, me agregaron ejercicios de correr de costado y haciendo secuencias raras de paso y después de un verano agotador, me dieron el alta.

Abril 2007-Presente

Me dieron el alta pero todavía no estaba bien, bien. Me faltaban los últimos detallecitos. Así que todavía me dolía la rodilla de vez en cuando y se me inflamaba cada vez que hacía movimientos raros. Aparte mi sobrepeso tampoco ayudó mucho.
En mayo entré a laburar a mi laburo actual y hubo 2 actividades que me hicieron mierda la rodilla:

1. Día de actividades "corporativas" de la empresa. Donde nos llevaron al Club de Amigos a que nos lavaran el cerebro haciéndonos creer que la empresa es lo más importante del universo. La actividad fue una mierda, pero había un castillo inflable que estaba buenísimo, pero que fue la perdición de mi rodilla.


2. Basket. Esa misma semana fui a jugar al basket en cancha de cemento.

El combo fue letal. Estuve rengo por 3 semanas, me asusté, fui al traumatólogo. Me dijo que me haga una radiografía y lo vea de nuevo. Cuando fui a verlo de nuevo con la radiografía, empezó a sacarle fotos porque le parecía que había hecho una obra de arte con mi rodilla y estaba muy orgulloso, me dijo que no haga más boludeces y que estaba bien y se fue a un congreso con las fotos de mi rodilla.
Así que esperé a que se terminara de desinflamar la rodilla y empecé a hacer "deporte de bajo impacto". O sea, volví a nadar. La natación me vino bárbaro y mi rodilla se terminó de mejorar. A mitad de año pusieron clases de yoga en el laburo y empecé a ir (y sigo yendo). Así estoy terminando de recuperar la flexibilidad.
Por último, hará un mes que volví a las canchas de fútbol 5. No se nota ninguna secuela de la lesión, salvo que ahora juego con una rodillera puesta. Mi habilidad está intacta y hasta estoy jugando un poquito mejor que antes. Igual eso no quiere decir mucho, era desastroso y lo sigo siendo.
O sea, si se rompieron la rodilla, no sean boludos, opérense. Es mucho laburo pero pueden volver a las cosas que hacían antes. Una cosita más. Lo que me dijeron los médicos es que si no se operan y tienen los ligamentos rotos, van a tener una artitris grosa en unos años.
Espero que les sea de utilidad a todos los googleros que llegan por acá buscando información sobre la reconstrucción de los ligamentos.

Happy hacking,
Aureliano.

Si PHP es KK, ¿por qué lo usan tanto?

Hace unos meses dije que PHP es KK en un post de este blog que generó bastante polémica (al menos en los comentarios del post). Y esa discusión me puso a pensar "¿qué cosas buenas tiene PHP?". Claramente, mucha gente lo usa y sirve para hacer un montón de cosas. Bueno, estas son algunas de las cosas que hacen que php y su entorno sean buenos (sin ningún orden en particular):

• Está en todos lados. Es muy fácil conseguir hosting con php y gente que sepa programar en php. También hace que haya millones de soluciones para pequeños problemas disponibles. Y un montón de gente muy inteligente haciendo soluciones para problemas de php como ésta o ésta.
  
• La documentación de php es buenísima. Siempre que busqué cosas ahí las encontré de toque.
• El entorno es fácilmente instalable. En linux, generalmente viene con la distribución y en Windows es solo cuestión de bajar e instalar un WAMP.
• El ciclo de desarrollo es muy rápido. Nada de compilar. Nada de reiniciar ningún server. Cambiás un toque un script y ves el resultado inmediatamente.

Estos son todos buenos motivos. Algunos de estos solo valen porque php ya es popular, pero otras no. En particular, el manejo de la documentación de php es algo que es buenísimo.

Happy hacking,
Aureliano.

Mañana empiezo el doctorado

Mañana a las 9:30 empiezo a cursar mi primera materia del doctorado en ingeniería informática en el ITBA, que es "Teoría de Tipos". Así que voy a estar más ocupado. De todas maneras voy a tratar de mantenerme escribiendo algunas cositas en el blog de vez en cuando.

Deseenme éxitos,
Aureliano.

Clases abiertas - Ejemplo práctico

Estoy mirando una biblioteca para acceder a bases de datos muy copada que se llama sequel. En la misma no hay que declarar nada y el mapeador solo sabe como hacer para acceder a todo (como debería ser). Y quise ver como hace el sql que va a la base, así que prendí el irb e hice un poquito de "aspect programming alla ruby". Primero importé la biblioteca y el driver para postgres y les agregué datos (todo usando la biblioteca sequel desde adentro del irb y sin escribir una línea de SQL).

Pero después me agarró la duda de cómo se generaba el SQL. ¿Tendría quizás alguna forma de hacer un SQL injection si uso la biblioteca para hacer una página web? Lo que siempre me gustó de bibliotecas como ActiveRecord e Hibernate, es que me quitan la responsabilidad por estas cosas. Así que puse manos a la obra.

Una mirada rápida por la documentación y el código no me llevó a la opción de mostrar todo el sql que se ejecuta, así que tuve que hacer un toque de magia.

irb(main):042:0> class Sequel::Postgres::Dataset
irb(main):043:1>   alias_method :select_sql_old, :select_sql
irb(main):044:1>   def select_sql(*p)
irb(main):045:2>     sql = select_sql_old(*p)
irb(main):046:2>     puts(sql)
irb(main):047:2>     sql
irb(main):048:2>   end
irb(main):049:1> end

¿Qué hice? Hice "aspect programming alla ruby". Cambié cómo se hace para generar el sql de las consultas en postgres para que lo muestre por pantalla (solo en mi sesión de irb).

A partir de este momento (y hasta que lo vuelva atrás o salga del irb) me muestra el SQL de cada SELECT que haga a la base.

Así que ahora puedo mirar fácil que pasa si trato de inyectar SQL:

irb(main):053:0> user_name = "aaaa ' or 1=1"
=> "aaaa ' or 1=1"
irb(main):054:0> users.where(:name => user_name).all
SELECT * FROM users WHERE ("name" = 'aaaa '' or 1=1')
=> []

Soy feliz, y veo que la biblioteca parece estar bien pensada (al menos para esto).

Happy hacking,
Aureliano.

Nueva versión del bottle invaders

Estoy muy contento de anunciar la nueva versión del "Bottle invaders", en la cual el Señor Destapador (AKA: Mr Opener) defiende su planeta de una invasión de botellas extraterrestres rechochas de vino tinto.

En este release, le bajé los fps a 5 para que se parezca al space invaders original un poco más (y porque me pareció que queda más divertido) y cambié la lógica de colisiones del misil para que sea consistente con esa cantidad de fps.

Si quieren bajarselo está disponible acá.

Happy hacking,
Aureliano.

Requisitos renovación pasaporte

Hoy fui a renovar mi pasaporte y hacer mi cédula nueva (la anterior la perdí). No pude hacerlo porque me faltó un papel (/$%/#/$&%***+++###). Eso no impidió que me coma como 2 horas de cola al dope, así que les voy a contar cuáles son mis requisitos, que no tienen porqué ser los de ustedes (la burocracia suele ser así).
Cosas para llevar:

• Pasaporte viejo (si no tenés eso podés declararlo perdido, creo)
  
• Fotocopias de la 1a y 2a hoja)
• DNI
• Fotocopias 1a, 2a, 3a hojas y donde están tus votaciones.
• Libreta de casamiento si estás casado (esto es lo que yo no llevé y no me pidieron hasta 2 horas después de iniciar el trámite).

Las fotocopias las podés sacar durante el tiempo de espera, pero los documentos los tenés que llevar sí o sí.

Lo único bueno es que durante la espera pude scriptear con rake para que se armen el .tar.gz y el .zip del Bottle invaders.

Happy hacking,
Aureliano.

Bottle invaders - primer release

Hola,
acabo de subir a rubyforge el primer release del Bottle Invaders. En el mismo muestro al Señor Destapador luchando contra unas botellas rechonchas de vino que le disparan corchos. Este juego también lo hice usando la biblioteca Rubygame. Si quieren bajarlo pueden ir acá

Y por último, como una imagen vale más que mil palabras, les dejo un screenshot del juego en pleno juego.



Happy hacking,
Aureliano.

Problemitas con speedy

Empecé a notar que speedy está andando muy "lento", pero que las descargas largas andan bien. Así que dejé un pinga google corriendo un rato y estos son los resultados:

$ ping www.google.com

(un monton de carteles con los round-trips)

--- www.l.google.com ping statistics ---
1927 packets transmitted, 1679 received, 12% packet loss, time 4652040ms
rtt min/avg/max/mdev = 346.690/969.515/1856.932/147.656 ms, pipe 2

Aparentemente está algo muy saturado porque se pierden el 12% de los paquetes y hay round trips de 2 segundos (¡y de promedio es casi un segundo!)

¿Les está pasando lo mismo?
¿Tengo que unirme a speedy apesta?

Happy hacking,
Aureliano.

Un adelantito

Como ustedes ya saben, empecé a hacer jueguitos usando la biblioteca Rubygame. Como el primer juego ya está (SEUO), empecé el segundo. Es un clon del space invaders, que muestra al Señor Destapador defendiendonos de una forma muy particular de unos invasores que son como botellas de vino.
Como una imagen vale más que mil palabras, acá les muestro un snapshot:

Happy hacking,
Aureliano.

Compilando LaTeX con rake

En el laburo estoy escribiendo un paper (es parte de las cosas que tengo que hacer como investigador en seguridad informática) y, como soy un geek que se precia, lo estoy escribiendo en LaTeX.

El temita es que las figuras que tiene el paper las hice en MS Visio y que quiero tener un script automático para generar el .dvi a partir del .tex, el .bib y los archivos de Visio. Pero LaTeX no acepta archivos de Visio como imágenes, solo .eps (encapsulated postscript) y Visio a lo sumo escupe .wmf. Así que instalé el wmf2eps y entonces tuve una idea, ¿por qué no generar todo usando rake y uso win32ole para hacer automation con el Visio?.

Este es el resultado (que anda) del rakefile que uso para generar el paper:

require 'rake/clean'
require 'win32ole'

VIS = FileList['*.vsd']
EPS = VIS.ext('eps')
MAIN = "paper.tex"
DVI = "paper.dvi"
BIB = "paper.bib"

CLEAN.include(FileList["*.wmf", "*.aux", "*.bbl", "*.blg", "*.log"] )
CLOBBER.include(FileList[DVI], VIS.ext("eps"))

def windows_name(file)
  File.expand_path(file).gsub("/","\\").gsub(" ", "\\ ")
end

def visio()
  begin
    return WIN32OLE.connect("visio.application"), false
  rescue WIN32OLERuntimeError # Visio is not running
    return WIN32OLE.new("visio.application"), true
  end
end

def open_doc(visio, filename) 
  begin
    return visio.Documents(filename), false
  rescue WIN32OLERuntimeError # file not open
    return visio.Documents.open(filename), true
  end
end

def latex
  sh "latex", "-halt-on-error", MAIN do 
    |ok, res|
    unless ok
      puts "Error compiling LaTeX file (status=#{res.exitstatus})\n"
      exit
    end
  end
end

def bibtex
  sh "bibtex", "paper" do 
    |ok, res|
    unless ok
      puts "Error compiling bibtex file (status=#{res.exitstatus})\n"
      exit
    end
  end
end

file DVI => EPS + [MAIN, BIB] do
  latex
  bibtex
  latex
  latex
end

rule '.wmf' => '.vsd' do
  |t|
  visio_filename = windows_name(t.source)
  wmf_filename = windows_name(t.name)
  visio, close_visio = visio()
  document, close_document = open_doc(visio, visio_filename)
  document.Pages(1).Export(wmf_filename)
  document.Close if close_document
  visio.Quit if close_visio
end

rule '.eps' => '.wmf' do
  |t|
  wmf_filename = windows_name(t.source)
  dirname = windows_name( File.dirname(t.source) )
  sh "wmf2eps\\wmf2eps -o #{dirname} #{wmf_filename}"
end

desc "Generates dvi for paper"
task :dvi => DVI

desc "Generates images for paper from Visio files"
task :images => EPS

desc "Generates images for paper from Visio files"
task :default => :images

Espero que les sirva esto, y que ruby se vaya acercando a la academia.

Happy hacking,
Aureliano.

Mr Opener en rubyforge

Estoy muy contento de anunciar que el código de Mr Opener (anunciado en el post anterior) está disponible para todos los que lo quieran en rubyforge.

La página del proyecto es http://rubyforge.org/projects/mropener/.

Espero a futuro:

• Hacer un gem con este programa
• Hacer otro programita, que va a ser un clon del space invaders pero usando al Señor Destapador como personaje principal.
• Seguir con más programas con el Señor Destapador como personaje principal.
  

Happy hacking,
Aureliano.