tl;dr: use the direct reply-to feature to implement RPC in RabbitMQ.

I’m currently working on a platform that relies heavily on RPC over RabbitMQ to move incoming requests through a chain of Node.JS worker processes. The high level setup for RPC is well described in RabbitMQ’s documentation; let’s steal their diagram:

We grew our RPC client code based on the JavaScript tutorial, using the amqp.node module. The first —admittedly naive— implementation just created a new connection, channel and queue per request and killed the connection after getting a reply:

const sendRPCMessage = (settings, message, rpcQueue) =>
  amqp.connect(settings.url, settings.socketOptions)
    .then((conn) => conn.createChannel())
    .then((channel) => channel.assertQueue('', settings.queueOptions)
      .then((replyQueue) => new Promise((resolve, reject) => {
        const correlationId = uuid.v4();
        const msgProperties = {
          correlationId,
          replyTo: replyQueue.queue
        };

        function consumeAndReply (msg) {
          if (!msg) return reject(Error.create('consumer cancelled by rabbitmq'));

          if (msg.properties.correlationId === correlationId) {
            resolve(msg.content);
          }
        }

        channel.consume(replyQueue.queue, consumeAndReply, {noAck: true})
        .then(() => channel.sendToQueue(rpcQueue, new Buffer(message), msgProperties));
      })));

That got us a long way during development but obviously failed to perform under non-trivial loads. What was more shocking is that it got dramatically worse when running it on a RabbitMQ cluster.

So we needed to refactor our client code. The problem is that most examples show how to send one-off RPC messages, but aren’t that clear on how the approach would be used at scale on a long-lived process. We obviously needed to reuse the connection but how about the channel? Should I create a new callback queue per incoming request or a single one per client?

Using a single reply-to queue per client

Based on the tutorial, I understood that the sensible approach was to reuse the queue from which the client consumed the RPC replies:

In the method presented above we suggest creating a callback queue for every RPC request. That’s pretty inefficient, but fortunately there is a better way – let’s create a single callback queue per client. That raises a new issue, having received a response in that queue it’s not clear to which request the response belongs. That’s when the correlation_id property is used.

We were already checking the correlationId, and just needed to create the reply-to queue in advance:

const createClient = (settings) =>
  amqp.connect(settings.url, settings.socketOptions)
    .then((conn) => conn.createChannel())
    .then((channel) => channel.assertQueue('', settings.queueOptions)
      .then((replyQueue) => {
        channel.replyQueue = replyQueue.queue;
        return channel;
      }));

I thought that would be enough to make sure the right consumer got the right message, but in practice I found that each message was always delivered to the first consumer. Therefore, I needed to cancel the consumer after the reply was processed:

const sendRPCMessage = (channel, message, rpcQueue) =>
  new Promise((resolve, reject) => {
    const correlationId = uuid.v4();
    const msgProperties = {
      correlationId,
      replyTo: channel.replyQueue
    };

    function consumeAndReply (msg) {
      if (!msg) return reject(Error.create('consumer cancelled by rabbitmq'));

      if (msg.properties.correlationId === correlationId) {
        channel.cancel(correlationId)
          .then(() => resolve(resolve(msg.content)));
      }
    }

    channel.consume(channel.replyQueue, consumeAndReply, {
      noAck: true,
      // use the correlationId as a consumerTag to cancel the consumer later
      consumerTag: correlationId
    })
    .then(() => channel.sendToQueue(rpcQueue, new Buffer(message), msgProperties));
  });

Enough? Only if the client processed one request at a time. As soon as I added some concurrency I saw that some of the messages were not handled at all. They were picked up by the wrong consumer, which ignored them because of the correlationId check, so they were lost. I needed to do something about unexpected message handling.

Requeuing unexpected messages

I tried using nack when a consumer received a reply to a message with an unexpected correlationId:

function consumeAndReply (msg) {
  if (!msg) return reject(Error.create('consumer cancelled by rabbitmq'));

  if (msg.properties.correlationId === correlationId) {
    channel.ack(msg);
    channel.cancel(correlationId)
      .then(() => resolve(resolve(msg.content)));
  } else {
    channel.nack(msg);
  }
}

Now the messages seemed to be handled, eventually. Only they weren’t: when I increased the load I saw message loss again. Further inspection revealed that the consumers were entering a weird infinite loop:

Consumer A gets message B; message B requeued
Consumer B gets message C; Message C requeued
Consumer C gets message A; Message A requeued

Repeated ad-infinitum. The same behaviour was reproduced using every possible combination of nack, reject and sendToQueue to send back the message.

Googling the issue, I read about the possibility of using Dead letter exchanges to handle those cases. But having to manually requeue unexpected messages felt weird enough; introducing a new exchange and queue sounded like a lot of effort to handle what should be a pretty standard use case for RPC. Better to take a step back.

Using a new reply-to queue per request

So I went back to a reply-to queue per request. This was marginally better than our initial approach since now at least we were recycling the connection and the channel. What’s more, that appeared to be the standard way to do RPC in RabbitMQ according to the few spots where I found non-tutorial implementation details, so, as Paul Graham would say, we wouldn’t get in trouble for using it.

And it worked well for us as long as we run a single RabbitMQ instance. When we moved to a RabbitMQ cluster the performance was pretty much the same as when we were creating connections like there was no tomorrow.

Using direct reply-to

We were seriously considering dropping the RabbitMQ cluster altogether (which meant turning our broker into a single point of failure), when I came across the link to the direct reply-to documentation. The first interesting thing there was that it confirmed why we were seeing such bad performance when running a RabbitMQ cluster:

The client can declare a single-use queue for each request-response pair. But this is inefficient; even a transient unmirrored queue can be expensive to create and then delete (compared with the cost of sending a message). This is especially true in a cluster as all cluster nodes need to agree that the queue has been created, even if it is unmirrored.

Direct reply-to uses a pseudo-queue instead, avoiding the queue declaration cost. And fortunately it was fairly straightforward to implement:

const createClient = (settings) => amqp.connect(settings.url, settings.socketOptions)

const sendRPCMessage = (client, message, rpcQueue) => conn.createChannel()
  .then((channel) => new Promise((resolve, reject) => {
    const replyToQueue = 'amq.rabbitmq.reply-to';
    const timeout = setTimeout(() => channel.close(), 10000);

    const correlationId = uuid.v4();
    const msgProperties = {
      correlationId,
      replyTo: replyToQueue
    };

    function consumeAndReply (msg) {
      if (!msg) return reject(Error.create('consumer cancelled by rabbitmq'));

      if (msg.properties.correlationId === correlationId) {
        resolve(msg.content);
        clearTimeout(timeout);
        channel.close();
      }
    }

    channel.consume(replyToQueue, consumeAndReply, {noAck: true})
    .then(() => channel.sendToQueue(rpcQueue, new Buffer(content), msgProperties))
  });

This worked just as we expected, even in the cluster. As the code shows, though, we were still creating a new channel per request and we needed to handle its closing, even when the response never came. Trying to use a single channel resulted in a “reply consumer already set” error, because the queue was always the same.

Creating so many channels didn’t feel right, so I filed an issue asking for advice in the amqp.node repo. The creator confirmed that that was indeed an anti-pattern and suggested not only using a single channel but registering a single consumer (i.e. a single callback function to handle all RPC responses). This meant introducing some structure to be able to route responses back to the promise that was expecting it. Using an EventEmitter turned out to be an elegant way to accomplish it:

const REPLY_QUEUE = 'amq.rabbitmq.reply-to';

const createClient = (settings) => amqp.connect(settings.url, settings.socketOptions)
  .then((conn) => conn.createChannel())
  .then((channel) => {
    // create an event emitter where rpc responses will be published by correlationId
    channel.responseEmitter = new EventEmitter();
    channel.responseEmitter.setMaxListeners(0);
    channel.consume(REPLY_QUEUE,
      (msg) => channel.responseEmitter.emit(msg.properties.correlationId, msg.content),
      {noAck: true});

    return channel;
  });

const sendRPCMessage = (channel, message, rpcQueue) => new Promise((resolve) => {
  const correlationId = uuid.v4();
  // listen for the content emitted on the correlationId event
  channel.responseEmitter.once(correlationId, resolve);
  channel.sendToQueue(rpcQueue, new Buffer(message), { correlationId, replyTo: REPLY_QUEUE })
});

Four years ago I wrote about my first (and last) experience with Common Lisp. I had high expectations and was disappointed; I ended up thinking maybe I should give Scheme or Clojure a try. It took a while, but I finally did it last month: learn Clojure. And it looks like a keeper.

Clojure has all the goodness of Lisp and functional programming, and it feels like a modern language: it addresses most of things that annoyed me about Common Lisp.

I’ve followed the great Clojure for the brave and true book by Daniel Higginbotham and then I’ve tackled a small project to train my skills. Here are my notes.

The good

• A consistent syntax, operation names and polymorphic functions. No weird illegible names, no type specific versions of the same function (I’m looking at you Common Lisp).
• Functional! Immutable! Expressive!
  • I don’t miss objects. Structuring programs in small functions; isolated, never changing data; those things just feel right. And I’m not even waving the old “shared state is bad for concurrency” flag; I don’t care —just now— about concurrency. This stuff makes programs simpler to reason about and test, and more fun to write.
  • There’s more: Clojure is so expressive and gives you enough options (I’m thinking loop, doseq, destructuring, etc.) that you don’t necessarily need to incur in “head/tail” recursive processing as much as I found in other functional languages, so the leap is not so rough.
• Did I say I don’t care about concurrency? I don’t. Mostly. Not at the language level, anyway. Clojure has a lot of cool tools for concurrency (future, delay, promise, pmap, core.async). Too much options, maybe, but I don’t mind about that either. I can just RTFM whenever I do have the need to do things concurrently. And, yes, immutability and pure functions make it simpler.
• A strong philosophy behind the language, that seems to drive its design. Python has this too and to me it’s its biggest selling point. Languages like C++ and increasingly JavaScript, on the other hand, feel like magic bags where features are added carelessly without consideration of the results. Java does have a strong philosophy: programmers are mostly idiots.
• Runs on the JVM. Seriously? I personally couldn’t care less about that but JVM languages seem to attract a lot of attention. There are tons of Java devs for sure and some of them seem to have a symbiotic relationship with the JVM: it’s like they aren’t cheating on Java if they keep the deal inside the VM. Why would people learn Groovy instead of Ruby or Python, god only knows, but because of the “Runs in Java” part there’s a better chance of finding a Clojure Job than one using Haskell, Scheme or most other functional languages around. That alone is enough reason for me to stick with Clojure instead of keep trying Lisp dialects, even if some other one may fit my taste better.
• Haven’t tried it yet, but the mere existence of ClojureScript is good news to me, specially considering how annoyed I am with the direction the JavaScript syntax and ecosystem is taking lately. This talk totally sold it to me.
• Said it before and say it again: forget about parenthesis. People seem to worry a lot about them beforehand, but as with Python whitespace indentation, once you’ve used it for five minutes it just goes away. Specially if you use the darn awesome Parinfer.
• Which brings me to: you don’t need Emacs for Lisp programming. Yes, I hear you, once I master Emacs I’ll be a more powerful programmer. But I’m trying to learn a weird language here, don’t make me also learn a weird, counter-intuitive editor at the same time. That would just increase the chances of me dropping the effort altogether. There are decent ports of Paredit for Sublime and Atom, which is good enough. But with Parinfer you just learn one command and forget about it, it just works.
• REPL driven development. Because of pure functions it’s easy to write a piece of code and test it right away in the REPL. Together with unit tests it pretty much removes the need for debugging.
• Leiningen looks good, it covers the small needs I had starting out and didn’t get in the way. Clojurians say it does a lot more than that, so great. Much better than the 17 tools you need to set up to have a Node.js project running these days.

The bad

• Namespace syntax is complicated, there are too many operations and keywords to do it (require, refer, use, alias, import and ns —which can do all of the others with a slightly different notation). It’s flexible but boilerplatish, even when sticking to ns:

(ns advenjure.game
  (:require [advenjure.rooms :as rooms]
            [advenjure.utils :as utils]
            [advenjure.verb-map :refer [find-verb verb-map]]))

• And while there’s no hard rule to keep a one to one relation between files and namespaces, there’s a strong convention to do it, so having to declare the package name in every file seems totally redundant (and Java-ish, let’s be honest).
• contains? Works in a counter-intuitive way for vectors.

That’s all I got.

And the ugly

Ok, there wasn’t much bad stuff, but there is some maybe not so good or arguably not good things I can think of.

• The built in operator set doesn’t follow the Unix and Python philosophy of small core and a lot of libraries that I like so much: the functions are way too many to easily remember, and they aren’t entirely orthogonal (some of them do the same thing in slightly different ways). Then again, the Clojure Cheatsheet, the REPL and doc are more than enough to cope with that.
• Polymorphism is great: sequence and collection functions work as expected in all data structures. The downside is that to do so the results are always coerced to seqs, which may be unexpected, specially for hash maps. In practice, though, I found myself just chaining those functions and rarely caring about the resulting type.
• Macros are powerful and awesome but the quoting syntax can get very tricky. I definitely need more experience to learn to reason about macro code, but the syntax will remain ugly. I guess that’s the cost you pay for being able to fiddle with how the language processes the code. In the end (much like Python metaclasses), macros are a great tool to keep in the box, but to use sparingly. So far every time I thought about implementing one I got away fine by using closures instead.
• Java does sneak in quite a bit and that’s a turn off. (spoiler alert: I don’t like Java). OK, Java interop is simple and powerful, probably the most straightforward language interfacing I’ve seen (boy was SWIG a nightmare). That being said, Java code inside Clojure looks like, well, Java code inside Clojure: it reeks. This wouldn’t be so much of a problem if needed only to interact with some third party Java libraries, but in practice I’ve found that there’s basic stuff lacking in the Clojure standard library and it’s either add a dependency or use Java interop. I saw this while solving an exercise from the Brave Clojure book: it asked to list the first results of a google search. The request should be a one liner using the built in slurp function but, wait, you need to set the User-Agent header to request google, so you end up with:

(with-open [inputstream (-> (java.net.URL. url)
                            .openConnection
                            (doto (.setRequestProperty "User-Agent"
                                                       "Mozilla/5.0 ..."))
                            .getContent)]

The end

Even though it’s not my ideal language and it may be less ideal to me than Python was, it looks like I’ll start to look for excuses to use Clojure as much as possible and it’ll be a while before I jump to study another new language.

Motivacional

La última vez que cambié de distribución fue allá por el 2013 cuando instalé Debian Weezy en mi por aquel entonces nueva Dell Inspiron 14R (podés leer más aca). Aquella vez cambié de Ubuntu (10.04 creo) a Debian 7. Hace un par de días compré un disco Samsung SSD, así que pense en tal vez probar otra distribución de Linux. Luego de hablar con un par de amigos, opté por probar Elementary Os.

Elementary es una distribución basada en Ubuntu con una apariencia a OS X. La versión actual se llama Freya (0.3) y está basada en Ubuntu 14.04. Lo que primero llama la atención es el diseño, los colores, ventanas, transparencias e íconos, bien logrados; algo esperable de una distribución que se proclama “una alternativa a OS X”. Es bastante ligero y veloz, considerando que posee pocos programas por defecto (por ejemplo no posee GIMP ni programa de ofimática) y muchos de ellos son programas propios. Por ejemplo el editor de texto por defecto es “scratch” y no el usual “gedit” (aunque son muy parecidos), asimismo el administrador de archivos se llama “pantheon-file”.

Desafortunadamente, estas alternativas no funcionan muy bien. Scratch suele colgare cuando falla la apertura de un archivos, cuando gedit no lo hace. Panteon-file por lo general funciona bien, sin embargo posee algunos comportamientos extraños y características faltantes, los dispositivos de almacenamiento USB no se montan automáticamente, no puedes previsualizar elementos en la papelera, y seleccionar múltiples elementos con Shift + Click Mouse puede ser realmente tedioso (si, no es chiste).

Hay otros problemas, algunos heredados de Ubuntu, tales como fallas en el login gráfico luego de una actualización, desconexión aleatoria del wifi, la pantalla del login no muestra correctamente un segundo monitor, etc. También tengo la sospecha de que la batería dura menos de lo usual (aunque no he podido corroborarlo fehacientemente, al no poseer una prueba estandar).

Resumen

Es un OS realmente bonito con gran potencial, con un gran equipo de diseñadores detrás de él. No recomendaría instalarlo todavía, pero si hacer un seguimiento cercano ya que no dista mucho de ser una gran distribución, aunque esos pequeños errores que lo apartan de serlo pueden ser razón suficiente para no utilizar este sistema.

Disculpa, pero esta entrada está disponible sólo en English.

Over most of last year I’ve been working along a couple of college friends on an action game for Android and it’s finally out. It’s done using cocos2d-x in C++, which is by no means a language I like, so hopefully I’ll get to write here about the experience I had building it.

In the meantime, here’s the link to install it from the google play store and the trailer of the game, for those who are interested in checking it out.

Si no vivis en un termo, seguro que en estos dias te llegó una imagen de un vestido y una discusión, si era blanco-dorado o azul-negro. Junto con esta imagen también comenzó a circular en twitter una imagen con un “efecto” similar.

Como se puede ver en la imagen, tanto las uñas como los labios tienen un color suave. Pero al hacer click en la imagen en twitter se veia algo como esto:

@candetinelli Jajaja… ahora se sigue con esto! Abran esta imagen pic.twitter.com/do27nT6gzk

— Mirna (@MIRNACARRIZOPOB) February 27, 2015

<script async="async" charset="utf-8" src="http://platform.twitter.com/widgets.js"></script>

Es decir, en el timeline se ve de color claro y al acceder a la foto se ve de color oscuro. Si bien pareciera magia o alguna rara ilusion optica, no se trata ni mas ni menos de que un simple “truquillo tecnico”.

Al descargar la foto en formato png, era evidente que las areas del labio y uñas poseian cierta transparencia, es decir que permitian que se vea en cierto grado el color del fondo. Si vemos un timeline de twitter, el fondo con el que contrastan los tweets es blanco, pero al abrir una imagen, el fondo es negro. De este modo se logra el efecto. El mismo es evidente al abrir el programa en GIMP (simil Photoshop) y cambiandole los colores del fondo.

Es bastante común hoy en día encontrarse en alguna red social como Twitter o Facebook alguna “encuesta” que invita a dar su opinión cuyas opciones son FAV o RT en el caso de Twitter y Like o Share en el caso de Facebook. Lo que quizá no nos sea intuitivo en primera instancia, es que esta metodología de encuesta facilita a quien la crea, “incentivar” un resultado por sobre el otro.

No es intuitivo porque uno es el que emite opinión, así que ¿como podría alguien manipular los resultados de la encuesta? Bueno, si bien el creador de la encuesta no puede alterar los resultados propiamente dichos, puede deliberadamente elegir que opción propagar más haciéndola más probable a la elección. Esto se logra aprovechando dos características de estas redes sociales. La primera es el alcance distinto que tienen las opciones fav-rt, like-share y el segundo es el scope  “solidario” que tienen las redes sociales.

Fav vs Rt

Lo primero a analizar es las diferentes opciones de voto y sus diferencias. La diferencia primordial de ambas opciones es la propagación que tienen. En twitter al favear un tweet, esa acción es “privada” y no se publica a nuestros seguidores; en cambio al retwittear un tweet el mismo va a aparecer en el timeline de nuestros seguidores. Lo mismo sucede en Facebook, con la diferencia que el like en determinadas circunstancias le puede aparecer a alguno de nuestros amigos, pero en muchísimo menor grado que si compartimos la “encuesta”.

Veamos esto de manera gráfica

Este gráfico representa una porción de una red social de 16 individuos. Cada punto es una persona y las conexiones representan amistad / seguimiento. Supongamos que el punto central (azul) es el que inicia una encuesta, en principio sólo aquellas personas que sigan o sean amigos de ella van a tener acceso a la encuesta. Veamos el siguiente gráfico

Ahora vemos como todos los puntos con conexión al punto central, se volvieron partícipes de la encuesta y es acá donde radica el punto más interesante de la cuestión. Veamos que sucede si los tres puntos superiores dan rt / share a la encuesta (verde)

Como sucedió con anterioridad, ahora los puntos conectados a ellos también tienen acceso a la encuesta. Acá vemos como los puntos conectados a aquellos que dieron fav / like (los puntos inferiores) no tienen acceso a la encuesta, lo que de por sí es un limitante.

¿Como el alcance puede ‘sugerir’ un resultado?

Pudimos ver como para que la encuesta tenga llegada más allá de la red del punto origen, es necesario que se le dé share / retweet a la encuesta. Y acá es donde entra en juego parte de los algoritmos y esencia de las redes sociales.

• Uno es más propenso a ser amigo / seguidor de aquellas personas con la que uno tiene un pensamiento afín.
• Uno es más propenso a replicar comportamiento de nuestros amigos / seguidores.
• Facebook nos publicará más sucesos de las personas con las que tenemos pensamiento afín que con las que no.

Este último caso quizá no sea tan evidente, pero si analizamos un poco nuestra cuenta de Facebook, nos daremos cuenta que en el newsfeed (página principal) en su mayoría nos aparecerán noticias de con quienes tenemos interacción (likes, mensajes, etc) que con los amigos con los que no tenemos interacción.

Entonces combinando tanto el alcance de compartir vs dar like, con las características arriba descriptas, es evidente como si deseamos que una opción gane por sobre otra, esa opción debe ser la de compartir. Obviamente hay varios factores que inciden en una encuesta de este tipo y lo sugerido no es deterministico, es decir que no es garantía de elección, pero es interesante analizar como puede incidir en un resultado.

Dada, entre otras cosas, mi posición política más que clara me cuesta mucho escuchar una cadena nacional; sin embargo hace dos días decidí (al menos por poco tiempo) escuchar la cadena nacional del día de la fecha. Si bien sabía que la presidente había sufrido cerca de navidad una fractura de tobillo, me sorprendió que apareciese en silla de ruedas.

Si a algo estamos acostumbrados los argentinos, es a la victimización política, donde todos los males del presente fueron heredados de las sucesivas dictaduras del siglo XX, las políticas de Alfonsín, las relaciones anglo carnales de Menem y DeLa Rua o a causas externas como la CIA, Clarín, la crisis de EEUU e incluso podríamos pensar en una bizarra aplicación del efecto mariposa y culpar a un nenito Europeo que decidió comprar una golosina europea en vez de una Arcor.

En parte considero que esto no es propio de la clase dirigente, sino una expresión de la sociedad en general. Nos gusta victimizarnos, lamentarnos, echarle la culpa a terceros, incluso utilizamos estos métodos para obtener beneficios económicos y políticos que simplemente nos degradan a nivel sociedad.

Ahora tomemos otro ejemplo, Alemania, durante el siglo XX sufrió dos Guerras Mundiales y desde el final de la última hasta los 90 que gran parte de su territorio se encontraba en dominio de la URSS. Hoy en día es potencia mundial, practicamente el prestamista de la UE y si bien estoy trazando con brocha gruesa hay que considerar que Alemania estuvo en peores situaciones que la nuestra. Cientos de miles de muertes por las guerras, ciudades destrozadas, hambrunas debido a la depreciación del marco y el bloqueo, sanciones económicas, etc.

Y si bien Argentina y Alemania son países diferentes en contextos diferentes, estos hechos me parecen muy significativos. Otra comparación (quizá mas banal) es la de las dos mandatarias, Cristina Kirchner y Angela Merkel. Durante el gobierno de Cristina hemos visto como se pintaba de demonio a distintos sectores como el Campo, el Grupo Clarin, EEUU, la “puta clase media”, etc. A esto se le suma el drama actoral mediático desde el fallecimiento del ex presidente Nestor Kirchner, pudiéndola ver vestida exclusivamente de negro, haciendo en cuanta oportunidad tenía mención a éste entre un pobre lagrimeo. En esta última cadena nacional se la vió vestida en su totalidad de blanco (casi queriendo hacer una alusión celestial) y en silla de ruedas.

Si bien es cierto que sufrió una fractura de tobillo, para una presentación de estas características tranquilamente se podría haber sentado en un sillón regular. Ahora comparemos con la otra mandataria, que años atrás sufrió una fractura de pelvis (también cerca de navidad) y en los primeros días de Enero del siguiente año se mostró sin demasiados esfuerzos andando en muletas.

Independientemente de quién en un futuro (tanto como individuo como partido político) sea el que gobierne este país, me gustaría que como sociedad tengamos un poco más de conciencia y responsabilidad, no sólo para hacernos responsables de nuestros propios errores, sino para reconocer a quienes no lo hacen.

En 2015, votá a conciencia y no seas pelotudo.

¿Vos programás gratis? Esa fue la interrogante fulminante que me dió una amiga estudiante de diseño gráfico para basar su negativa a entregarme un archivo vectorizado de unos fonts que ella había hecho y a mi me parecían copados. La pregunta me pareció curiosa porque SÍ, he programado gratis, he traducido gratis, he arreglado cosas gratis, etc. La otra cosa que me llamó la atención es que no es la primera persona estudiante de diseño que se niega de manera rotunda a hacer un favor, la última persona también tiró una negativa rotunda al preguntarle si le interesaba hacer algúna idea de logo para esta página.

Lo más irónico de todo es que estas mismas dos personas me han pedido favores, mi amiga me pidió fotos de una pantalla de un shield LCD Arduino porque el font estaba copado (cosa que hice sin drama) y la otra persona pidió auxilio al reventarle la PC con su tesis adentro. ¿Acaso ellos son unos hipócritas / forros? ¿Acaso consideran que un favor tiene más peso que otro? No lo creo, simplemente creo que es el contexto en el cuál se desarrollan, un contexto donde no parece haber mucha co-operación entre pares y donde te enseñan que al cliente se le cobra hasta la vuelta del sacapuntas.

Pero existen otras facultades / contextos donde ocurre exactamente lo mismo, por ejemplo hace unos días descubrí el proyecto NerdBanker el cuál es una suerte de híbrido entre Rincon del Vago y MercadoLibre, en donde se comercializa material de estudio y quién los efectua recibe dinero. Como idea para que algún estudiante corto de recursos haga unos pesos o como idea conceptual de negocio me parece interesante, pero en concreto no me gusta. ¿Que pasó con la idea de colaborar? No hablo a un nivel comunista / utópico, sino la simple idea de ayudar al pibe que tenés al lado. ¿Por qué todo tiene que pasar por la guita?

En concreto yo he aportado algunas reformas de código a diversos proyectos libres como FBHT, he hecho traducciones en Launchpad y actualmente estoy traduciendo Invent Your Own Computer Games with Python, he escrito en latex diversos examenes y apuntes disponibles en mi página pública, etc; y no considero que regalo trabajo, sino que colaboro a mejorar herramientas / material que yo he tenido a libre disposición o que si no lo tuve, me gustaría que otros lo tengan. ¿Cuantas veces deseaste que haya un parcial de ejemplo de una materia? ¿Un apunte copado para tener como referencia? ¿Por que se suele ser tan reacio a hacer estas cosas?

Quizá lo que marque la diferencia es que yo veo las bondades de una comunidad de software libre, de ver como con la colaboración de mucha gente un proyecto se lleva adelante; ¿cuantos de nosotros hemos forkeado un proyecto en GitHub para probarlo y nos resultó fantastico? ¿Por qué no podemos expandir esto a otros ámbitos fuera del software, como la facultad?

Por suerte en mi querida FIUBA existe una hermosa comunidad de alumnos que suele ser muy colaborativa, incluso hay una wiki donde se sube contenido actualizado que es de gran ayuda para todos los estudiantes.

La idea de este artículo es que de pié a la discusión (los leeré con atención en los comentarios) para que opinen.

Saludos!

Así como dice la frase que entre dos españoles hay tes opiniones, lo mismo parece estar sucediendo en Argentina; donde existe una gran polaridad entre adherentes y disidentes al Gobierno. Esto se ve en las opiniones que se expresan en las redes sociales, hay quienes aplauden ciegamente cualquier hecho del gobierno y también están quienes igual de ciegamente los critican. En el fondo generalmente hay muy poca objetividad, el objetivo de esta entrada es dar una mirada lo más objetiva posible (dentro de la subjetividad de quién escribe) respecto de la puesta en órbita del Satélite Argentino ARSAT-1.

El día de hoy, me tocó leer gran cantidad de opiniones. Quienes defendían la postura de que éste es un acontecimiento épico en el camino del desarrollo tecnológico nacional y quienes se “burlaban” considerando que se lanzó una heladera comprada en COTO. Ambas posturas (a mi criterio) son erróneas.

COTO Space Program

Una de las principales “quejas” que leí en contra del ARSAT es que en realidad no se trató de un satélite de 100% origen nacional, en parte esto es verdad y corresponde al paradigma de “épica” que últimamente utiliza el gobierno, sin embargo la realidad es que pocos (o ningún país) tiene la capacidad de desarrollar y fabricar todos los componentes de un satélite. Este satélite se compone de elementos desarrollados nacionalmente, fabricados algunos afuera y ensamblados localmente. Esto implica que la idea, la lógica del satélite surgió de la mente nacional, así como todos los productos de Apple son desarrollados en California pero fabricados en China.

El siguiente paso sería desarrollar la industria electrónica nacional para ser capaces de fabricar más componentes, no sólo para la industria aero-espacial, sino para satisfacer demandas industriales y comerciales. Pero esto es algo de lo que hablaré en el próximo segmento.

El satélite blanco de San Martín

Un recurso muy utilizado últimamente en los discursos, es el de constituir la idea de que todo paso del gobierno constituye un episodio en una historia épica, que posiciona a la Argentina en un lugar privilegiado mundialmente y se realizan acciones que quedarán en la Historia. Y es a este “paradigma” que recaen la mayoría de mis objeciones.

Sin nosotros no habría ARSAT-1 (link)

Estando en vísperas de un año de elecciones presidenciales ésta clase de frases abundan, tratando de afianzar la idea de que de suceder otro gobierno (o haber sucedido) estos proyectos no serian posibles. La realidad que éste no es el primer satélite Argentino (si geoestacionario), durante los 90 en la gestión de Carlos Saúl me toco el huevo izquierdo Menem se lanzaron diversos satélites bajo la órbita de CONAE (si…pun intended). Y si bien es real que este gobierno reactivó proyectos necesarios (diferenciar necesario de suficiente) para el desarrollo nacional, el uso político fue por varios órdenes mayor al impacto real de estos proyectos en la “soberanía tecnológica” (haciendo énfasis en que no es insignificante el impacto, sino muy grande el uso político).

Soberanía Tecnológica

Acá es donde a mi criterio hace agua el “relato”. SI, es ultra necesario tener satélites nacionales propios y es positivo que el gobierno financie dichos proyectos; pero la realidad es que dichos proyectos tienen poca correlación con el desarrollo de tecnologías nacionales a un nivel general. Es decir, debemos estar contentos de fabricar satélites propios, pero si luego la industria nacional no es capaz de fabricar (y por fabricar me refiero a investigar, desarrollar y crear) un celular, microondas, lavarropas, algo está mal. Y acá es donde recae una de las mayores dicótomas del gobierno.

Por un lado se financia con dinero estatal “mega”‘-proyectos, pero a la vez se dificulta al individuo o industrias desarrollar independientemente. Como dije en de mi anterior post respecto de la tecnología, Argentina y el Desarrollo Tecnológico, los países que hoy son grandes mecas de la tecnología lo hicieron gracias a la libertad y facilidad de los individuos a desarrollar. Esto NO es un hecho en Argentina, muy por el contrario las trabas a las importaciones y gravámenes impositivos lo dificultan.

Es una gran hipocresía por un lado aseverar la importancia de establecer telecomunicaciones nacionales, y a la vez si yo como radioaficionado deseo comprar una radio para desarrollarme en el área, gracias a los impuestos me saldría el doble respecto del valor comercial en EEUU. Por ejemplo una base Yaesu 2900R en EEUU sale 190 u$d lo que se traduce en $1600 acorde el dolar oficial ($8,5 que es al cual se importa), sin embargo en los mercados locales el precio ronda los $4000. Cuando este no se trata de un bien “suntuoso” como quiza podria ser un televisor LED.

Hace poco en un artículo de La Nación, salió la noticia de que la mini computadora educativa Raspberry Pi llegó a los 3,8 millones de ventas, destacando su rol en la educación de los chicos sobre computación y electrónica. Una Raspberry Pi B⁺ se vende en EEUU a 38 u$d que corresponderian a $330, sin embargo se comercia localmente alrededor de los $1000. Lo mismo sucede con los Arduino, cuyo precio del modelo MEGA 2560 R3 es de 27 u$d ($250) y localmente se comercializa a $900 la versión oficial y $400 la versión China. Y ni hablar de la disponibilidad de elementos adicionales que le dan aún más valor agregado a estos productos.

Resumen

Es muy positivo que se afronten estos proyectos por parte de instituciones estatales (o con financiamiento estatal), pero la realidad es que poca correlación tienen estos con un desarrollo global de la industria nacional. Desde el discurso se reconoce la necesidad de que más gente se emplee en estos rubros, pero en la realidad las cuestiones burocráticas y/o económicas dificultan esto. Nos ponemos contentos de lanzar un satélite, pero en comercios de electrónica no se consiguen inductancias y/o integrados. 

Cuando se comprenda la idea (y se aplique) de que el vector de desarrollo nacional más que el Estado, debe ser mediante la posibilidad de que los individuos puedan desarrollar sus propias ideas y proyectos, es cuando estaremos bien encaminados hacia el verdadero desarrollo nacional y soberanía tecnológica. Mientras tanto, antes de abrir la boca, fijate cuán grande es el buzón. 

Introduction

This post describes an authentication method for socket.io that sends the credentials in a message after connection, rather than including them in the query string as usually done. Note that the implementation is already packed in the socketio-auth module, so you should use that instead of the code below.

The reason to use this approach is that putting credentials in a query string is generally a bad security practice (see this, this and this), and though some of the frequent risks may not apply to the socket.io connection request, it should be avoided as there’s no general convention in treating urls as sensitive information. Ideally such data should travel on a header, but that doesn’t seem to be an option for socket.io, as not all of the transports it supports (WebSocket being one) allow sending headers.

Needless to say, all of this should be done over HTTPS, otherwise no security level is to be expected.

Implementation

In order to authenticate socket.io connections, most tutorials suggest to do something like:

io.set('authorization', function (handshakeData, callback) {
  var token = handshakeData.query.token;
  //will call callback(null, true) if authorized
  checkAuthToken(token, callback);
});

Or, with the middleware syntax introduced in socket.io 1.0:

io.use(function(socket, next) {
  var token = socket.request.query.token;
  checkAuthToken(token, function(err, authorized){
    if (err || !authorized) {
      next(new Error("not authorized"));
    }
    next();
  });
});

Then the client would connect to the server passing its credentials, which can be an authorization token, user and password or whatever value that can be used for authentication:

socket = io.connect('http://localhost', {
  query: "token=" + myAuthToken
});

The problem with this approach is that it credentials information in a query string, that is as part of an url. As mentioned, this is not a good idea since urls can be logged and cached and are not generally treated as sensitive information.

My workaround for this was to allow the clients to establish a connection, but force them to send an authentication message before they can actually start emitting and receiving data. Upon connection, the server marks the socket as not authenticated and adds a listener to an ‘authenticate’ event:

var io = require('socket.io').listen(app);

io.on('connection', function(socket){
  socket.auth = false;
  socket.on('authenticate', function(data){
    //check the auth data sent by the client
    checkAuthToken(data.token, function(err, success){
      if (!err && success){
        console.log("Authenticated socket ", socket.id);
        socket.auth = true;
      }
    });
  });

  setTimeout(function(){
    //If the socket didn't authenticate, disconnect it
    if (!socket.auth) {
      console.log("Disconnecting socket ", socket.id);
      socket.disconnect('unauthorized');
    }
  }, 1000);
}

A timeout is added to disconnect the client if it didn’t authenticate after a second. The client will emit it’s auth data to the ‘authenticate’ event right after connection:

var socket = io.connect('http://localhost');
socket.on('connect', function(){
  socket.emit('authenticate', {token: myAuthToken});
});

An extra step is required to prevent the client from receiving broadcast messages during that window where it’s connected but not authenticated. Doing that required fiddling a bit with the socket.io namespaces code; the socket is removed from the object that tracks the connections to the namespace:

var _ = require('underscore');
var io = require('socket.io').listen(app);

_.each(io.nsps, function(nsp){
  nsp.on('connect', function(socket){
    if (!socket.auth) {
      console.log("removing socket from", nsp.name)
      delete nsp.connected[socket.id];
    }
  });
});

Then, when the client does authenticate, we set it back as connected to those namespaces where it was connected:

socket.on('authenticate', function(data){
  //check the auth data sent by the client
  checkAuthToken(data.token, function(err, success){
    if (!err && success){
      console.log("Authenticated socket ", socket.id);
      socket.auth = true;

      _.each(io.nsps, function(nsp) {
        if(_.findWhere(nsp.sockets, {id: socket.id})) {
          console.log("restoring socket to", nsp.name);
          nsp.connected[socket.id] = socket;
        }
      });

    }
  });
});

Si entendiste el título no hace falta que te explique la imagen, de lo contrario la imagen pertenece a la serie Futurama, más precisamente al capítulo en el cual Bender (el robot) posee la capacidad de replicarse. El problema es que se está replicando sin control y el brillante profesor Farnsworth logró encontrar una serie que define la capacidad de replicación de Bender. Cuando muestra la serie todos se espantan (excepto Fry que no parece entender nada) al ver que la expresion no es convergente.

Conver..que?

Convergente, implica que luego de una cantidad muy grande de tiempo (mejor dicho términos) la serie va a tender a cierto valor. Que sea no convergente implica lo opuesto, que no existe ningún valor al cuál la serie se acerque. Esta serie es una de ellas, veamos porque.

Veamos que si es muy grande el se vuelve insignificante. Para no dividir por cero redefino.

Acá estaríamos tentados a pensar que si converge, ya que cuando es suficiente grande el resultado de la división va a tender a , para analizar mejor esto escribamos alguno de los términos.

Agrupando algunos términos

Cada uno de los términos agrupados entre paréntesis es igual o mayor a por lo que si ademas agrupamos de a dos de estos terminos vamos a tener una suma mayor a lo cual es evidente que no hay ninguna convergencia.

El barman

Veamos otro ejemplo: entra un grupo grande de personas, el primero pide una cerveza, el segundo pide “la mitad de lo que pidio el primero”, el tercero dice “la mitad de lo que pidió el segundo” y así sucesivamente. El barman sirve dos cervezas. Veamos que forma tiene esto:

Esto es una serie geometrica con termino general menor a uno, por lo cual converge y en particular converge a 2.

que con es claro que tiende a 2.

De esto podemos no solo afirmar que Matt Groening tiene un humor bastante nerd, sino también que las series son interesantes de estudiar, no solo por su capacidad de representar de manera ‘sencilla’ ciertos escenarios sino también que a veces su resultado no es tan intuitivo como uno tendería a pensar.

A context manager is not the answer.

Think twice before mock.patch.

And, God, whatever that is, don’t put it in __init__.py

Luego de los sucesos de The Pirate Bay y CAPIF, estando un poco mas atento a la ‘comunidad’ me encuentro con este proyecto de ley y no pude mas que sorprenderme de la pobreza del mismo, tanto en profundidad técnica como en argumentativa. Al ahondar en el perfil público de twitter de la senadora presentante (Sandra Gimenez), no hice más que profundizar mis dudas sobre el conocimiento de la senadora en la materia.

Como diría Jack el Destripador “Vamos por Partes” (Saludo a mis profesores del secundario que solían hacer ese chiste).

Artículo 1o - A partir de la sanción de la presente ley será obligatorio
para las empresas que ofrecen el servicio de acceso a internet a
usuarios finales la instalación de filtros que permitan bloquear el
acceso a la lista de sitios de acceso restringidoque determine la
Comisión Nacional de Comunicaciones.
El servicio básico implicará la instalación del acceso a internet con el
filtro referido a excepción de los casos en los que el usuario manifieste
expresamente y por escritosu voluntad de mantener acceso irrestricto
a internet.

• “Filtros”, no establece ningún detalle de como se implementaría este filtro. DNS, IP? Veremos como sigue…
• El “filtro” seria por defecto a no ser que se exprese explícitamente y por ESCRITO (siglo XXI por favor) la no conformidad. No sería mejor que el filtro pueda solicitarse y que por defecto no esté?
• Con que criterios la CNC establecería el bloqueo a un sitio?

Continuemos…

Artículo 2o - La Comisión Nacional de Comunicaciones elaborará y
mantendrá actualizado el contenido de la lista de sitios de acceso
restringido en el que identificará las páginas con contenido
pornográfico a través de una estrategia acordada en el marco de la
Comisión Argentina de Políticas de Internet.
El referido listado será el que utilicen los filtros a los que hace
referencia el artículo 1o de la presente ley para bloquear los sitios de
acceso restringido

• Sigue sin especificar los criterios.

Artículo 3o - Aquellos usuarios del servicio de acceso a internet que
decidan no bloquear los sitios de acceso restringido deberán solicitar
expresamente y por escrito al proveedor de acceso a internet que no
le sea instalado el filtro.

• Siglo XXI e insisten con tramites burocráticos.

Artículo 4o - Las empresas que proveen el servicio de internet tienen
un plazo de 180 días para instalar los filtros a los que hace referencia
el artículo 1o de la presente ley a todos los usuarios existentes al
momento de la sanción de la presente Ley a excepción de aquellos
que manifiesten expresamente y por escrito que desean mantener
acceso irrestricto a internet.

• Tienen 180 días para implementar un filtro, que no se especifica ni medidas técnicas, ni criterios.

Ahora algunos de los los “fundamentos”

...como todo cambio, también han surgidoo se han favorecido
conductas desviadas queagreden a los más elementales valores de
nuestrasociedad, en especial a la dignidad humana.Una de ellas,
quizás, la de mayor alarma social,es la distribución y consumo de
contenidos depornografía infantil, puesto que se trata de unfenómeno
criminal que se ha multiplicado conla multitud de canales de
distribución que ofrecela red.

 . La Oficina de las Naciones Unidas contra la Droga y el Delito
(ONUDD) ha reconocido al tráfico de drogas, de armas y de personas
como tres de las actividades delictivas más lucrativas a nivel mundial;
en el caso de esta última, se calcula una derrama económica de 32 mil
millones de dólares anuales. De este círculo delictivo, la pornografía
constituye un negocio central ...

Por todo lo expuesto y teniendo en cuenta que existen herramientas
informáticas que nos permiten proteger a los menores de una
exposición temprana a contenidos sexuales que afecten su desarrollo,
este proyecto de ley busca reducir la exposición de los menores a
contenido sexual en forma anticipada a través de un mecanismo de
filtro de sitios de acceso restringido, los cuales deberán ser
identificados en forma permanente por la autoridad de aplicación, de
forma tal que todos los usuarios de internet, si no manifiestan
expresamente su voluntad de tener un acceso irrestricto, mantendrán
bloqueados los sitios identificados como aquellos con contenido
sexual.

OK, espérenme unos sorbos de té mientras reacomodo las neuronas en furiosa sinapsis intentando de entender esto. Claramente los fundamentos de la Sra. Senadora consisten en mezclar cosas, meter algunas cifras cualquiera, batir y sacar un proyecto de ley. Empieza hablando de la pornografía infantil, luego habla de estadísticas de trata de personas y termina hablando de cuestiones morales y la pronta exposición de los chicos a contenido sexual.

Si a eso le sumamos algunos tweets de su perfil, por ejemplo (ver mas):

El filtro propuesto es para sitios de pornógrafia infantil!!!! A Ud le gusta ver violaciones de niños y niñas????

— Sandra GImenez (@SandraSenadora) julio 13, 2014

<script async="" charset="utf-8" src="http://platform.twitter.com/widgets.js"></script>

Acá queda demostrado el mejunje que la Sra. hace. Según su tweet el propósito es bloquear el acceso a los sitios de pedofilia. Si ese fuera el caso, no seria mejor reportar a las autoridades competentes e investigar quienes suben ese material a internet? Ademas recordemos que según el proyecto podríamos solicitar por escrito que no se nos aplique el filtro y así poder acceder a material pedófilo. La lógica? Junto con Candela y la moto.

Suponiendo que el caso en realidad sea proteger la integridad de los niños e impedir una exposición accidental a material sexual, el proyecto de ley seria intentar matar una hormiga con una bomba atómica (y ni siquiera conseguir matarla).

• Por qué todos los usuarios deben “sufrir” este filtro? Acaso no sería mejor, a aquellos usuarios interesados, ofrecerles el servicio como opción?
• Ya existe software (y hardware) con capacidades de Control Parental. Establecer este control a nivel ISP es complicar las cosas innecesariamente. No reinventemos la rueda (y menos cuadrada). Eduquemos en la utilización de las herramientas ya disponibles.
• Ni hablar que viola los principios de neutralidad de la red.

A todas estas incongruencias fundamentales se le suma la falta de especificaciones técnicas de como se implementarían los “filtros”. Acaso van a establecer un blacklist de DNS / IPs ? Van a hacer una base de datos de todas las paginas web con contenido pornográfico? Como bloqueas todos los perfiles de twitter, tumblr, facebook, blogspot, etc; con contenido sexual? Como impedís que un niño curioso googlee “teta” (o una búsqueda más audaz) y que le aparezcan las imágenes asociadas? Suerte con eso…

Ni hablar de los conflictos colaterales a tener una lista negra de páginas, gestionada por un organismo oficial, me remito al conflicto de The Pirate Bay y CAPIF / CNC.

Resumiendo

Este proyecto de ley redactado por la esposa del Reverendo Alegría, nos muestra un número interesante de inconsistencias, de argumentos flojos, datos aleatorios y una absoluta y completa falta de argumentos técnicos que demuestren algún conocimiento en la materia.

Sra. Sandra Gimenez, con gusto la asesoro (ad-honorem, no se preocupe) en esta materia. Quiere saber como impedir el acceso de menores a paginas inadecuadas? Educando a los padres y educando a los menores. No hay herramienta técnica que supere a la educación. Los filtros informáticos se superan, los filtros educacionales no. Por eso cuando damos charlas en colegios primarios y secundarios, lo principal es educar a los padres y a los chicos; si bien se presentan herramientas informáticas, lo principal se trata de que los mayores sean capaces de tener un seguimiento de los menores y de charlar con ellos en lo que respecta la sexualidad y los medios digitales.

Como diría un profesor mio en la facultad “Si no sabe, pregunte. No haga burradas”.

Estimado alumnos del Dpto. de Estabilidad:

Es intención del departamento contar con encuestas donde los estudiantes expresen su opinión sobre las materias y los docentes del departamento. Consideramos estas encuestas un elemento esencial tanto para los concursos de docentes auxiliares como para poder mejorar la enseñanza en nuestro departamento.

Mucho les agradeceré su colaboración para la difusión de la obligatoriedad y la responsabilidad en el llenado de las encuestas. El plazo para completar la encuesta es el 15/08 y se exigirá el comprobante en el momento de la firma de la libreta en el departamento.

Muchas gracias a todos por su colaboración.

Raul Bertero

Director del Dpto. de Estabilidad

ACLARACIONES PARA REALIZAR LA ENCUESTA:

Las encuestas se completan on line y son de carácter obligatorio y anónimo.

Es muy fácil.

Si no estás matriculado en el Campus del curso, MATRICULATE

Llená la encuesta.

Llená tus datos para asentar que llenaste la encuesta.

Este último paso es el que garantiza que la encuesta que llenaste sea anónima y le sirve al departamento como comprobante.

MUCHAS GRACIAS