Mesh Network

Esta ilustración fue generada para explicar el funcionamiento de una red enmallada (mesh network) en cuanto figura de distribución y conexión entre nodos. La aplicación práctica de esta red fue discutida en el post anterior, describiendo la necesidad de una arquitectura de red resistente a cataclismos como el pasado terremoto y donde todos los nodos aportan, yendo más allá de ser meros clientes. Una red pública es aquella donde cada participante expande su alcance por el simple hecho de pertenecer.

show code

void setup() {
  size(500, 500);
  NODES = new ArrayList();
  for (int i = 0; i < numNodes; i++) {
    Node n = new Node(random(margin, width-margin), random(margin, height-margin));
    if (random(1) >0.25) {
      n.device = true;
    } else {
      n.r *= 1.5;
    }
    NODES.add(n);
  }
  newNode = false;
  smooth();
}

void draw() {
  background(255);
  if (newNode) {
    NODES.add(current);
    newNode = false;
  }

  for (int i = 0; i < NODES.size (); i++) {
    Node n = (Node)NODES.get(i);
    n.calc();
    n.renderLinks();
  }

  for (int i = 0; i < NODES.size (); i++) {
    Node n = (Node)NODES.get(i);
    n.calc();
    if (n.device) {
      n.renderDevice();
    } else {
      n.renderNode();
    }
  }
}

class Node {
  int id; // the ID of this node
  float x, y; // position
  float r; // radius
  float signal; // ammount of signal
  boolean on; // is it on?
  boolean over; // is the mouse over this one?
  ArrayList nodes; // list of nodes that are connected to this one
  boolean device = false;
  float angle, step;

  Node(float X, float Y) {
    count++;
    id = count;
    x = X;
    y = Y;
    signal = 0;
    on = true;
    nodes = new ArrayList();
    r = 7.0;
    angle = random(TWO_PI);
    step = random(1);
  }

  void renderNode() {
    if (over) {
      noFill();
      stroke(linkColor);
      strokeWeight(.50);
      ellipse(x, y, nodeScope, nodeScope);
      fill(nodeFillColor);
      stroke(nodeStrokeColor);
    } else {
      fill(nodeFillColor, 150);
      stroke(nodeStrokeColor, 50);
    }
    if (on) {
      strokeWeight(3);
    } else {
      strokeWeight(0.5);
    }
    ellipse(x, y, r, r);
  }

  void renderDevice() {
    move();
    if (over) {
      noFill();
      stroke(linkColor);
      strokeWeight(.5);
      ellipse(x, y, nodeScope, nodeScope);
      fill(deviceFillColor);
      stroke(deviceStrokeColor);
    } else {
      fill(deviceFillColor, 150);
      stroke(deviceStrokeColor, 150);
    }
    if (on) {
      strokeWeight(1);
    } else {
      noStroke();
    }
    ellipse(x, y, r, r);
  }

  void renderLinks() {
    if (on) {
      stroke(linkColor, 100);
      for (int i = 0; i < nodes.size (); i++) {
        Node n = (Node)nodes.get(i);
        float d = dist(x, y, n.x, n.y);
        float sw = map(d, r, nodeScope, 5, 0.1);
        sw = constrain(sw, 0.01, 20);
        strokeWeight(sw);
        line(x, y, n.x, n.y);
      }
    }
  }

  void calc() {
    nodes.clear();
    for (int i = 0; i < NODES.size (); i++) {
      Node n = (Node)NODES.get(i);
      if (id != n.id) {
        float nodeDist = dist(x, y, n.x, n.y);
        if (nodeDist <= nodeScope &#038;&#038; n.on) {
          nodes.add(n);
        }
      }
    }
  }

  void move() {
    noiseSeed(id);
    angle += (noise((float)millis()/100.0) - .5) * HALF_PI;

    x += cos(angle)*step;
    y += sin(angle)*step;
  }
}

boolean OVER;
ArrayList NODES;
int numNodes = 50;
int count = 0;
float margin = 100;
float nodeScope = 60;
boolean newNode;
Node current;

color nodeFillColor = #F06E1D;
color nodeStrokeColor = #8E3E0B;
color linkColor = color(86, 115, 124, 80);
color deviceFillColor = #1FCCFF;
color deviceStrokeColor = #02A8D8;

void keyPressed() {
  if (key == 'a') {
    nodeScope += 5;
    println("node scope = "+nodeScope);
  }
  if (key == 'z') {
    nodeScope -= 5;
    println("node scope = "+nodeScope);
  }
  if (key == ' ') {
    for (int i = 0; i < NODES.size (); i++) {
      Node n = (Node)NODES.get(i);
      n.on = !n.on;
    }
  }
  if (key == 'x') {
    setup();
  }
  nodeScope = constrain(nodeScope, 5, width);
}

void mouseMoved() {
  float d;
  for (int i = 0; i < NODES.size (); i++) { 
    Node n = (Node)NODES.get(i); 
    d = dist(mouseX, mouseY, n.x, n.y); 
    if (n.r*1.5 >= d) {
      OVER = true;
      n.over = true;
      current = n;
    } else {
      OVER = false;
      n.over = false;
    }
  }
}

void mouseDragged() {
  if (OVER) {
    if (current.over) {
      current.x = mouseX;
      current.y = mouseY;
    }
  }
}

void mouseReleased() {
  if (current.over && mouseButton==RIGHT) {
    current.on = !current.on;
  }
}

Cómo funciona

  • arrastre nodos para reconfigurar la red
  • teclas a y z modifican el alcance de cada nodo
  • botón derecho sobre el nodo lo enciende o apaga
  • tecla i sirve para invertir encendido/apagado de todos los nodos
  • x regenera la distribución de nodos

Cómo diseñar democracia en la red

Escribo este post porque veo que ya están ocurriendo cosas en este ámbito y hablar de esto ahora deja de ser sólo teoría. Mi amigo Jorge planteó esta pregunta en políticaestero.tv (una nueva plataforma para la conversación política en Chile), respecto de cómo la política chilena puede recibir al espacio digital y veo con bastante expectación cómo comienza a configurarse una mirada más propositiva y constructiva en torno a la potencia de este medio como soporte para la democracia.

A continuación me quiero referir a ciertos puntos que considero críticos para abordar el diseño de plataformas de conversación política en la red fortaleciendo el poder de la participación.

La Infraestructura

La democracia parte de una la base: lo “en común”, aquello que es patrimonio público. La discusión política también ha de ser pública y ha de desarrollarse en un espacio público.

“It is a fundamental rule of their government, that no conclusion can be made in anything that relates to the public till it has been first debated three several days in their council. It is death for any to meet and consult concerning the State, unless it be either in their ordinary council, or in the assembly of the whole body of the people.”1

El distingo público-privado en la red es difuso y se debe principalmente al origen de la inversión de la infraestructura que posibilita la existencia de ese espacio (o servicio). Los proveedores del servicio de conexión a Internet —o ISPs— son los que delinean y configuran el aspecto de la red, es decir, las proximidades y distancias en este espacio.

Entonces, una de las principales barreras para la validación de los discursos verdaderamente democráticos es que toda la discusión ocurre sobre infraestructura es privada. A pesar de tener principios basados en la apertura, los soportes siguen siendo corporativos. Es como un mall, que está abierto al público pero no es público.

Una posible vía para revertir esta situación es promover otra arquitectura para la red, por ejemplo, la propuesta por la iniciativa OLPC que aboga por la topología de malla, donde cada computador es un nodo replicador, es decir, cada participante se contituye como el medio mismo.

La Relevancia

Temas semejantes deben tender a confluir y no a disgregarse. Todos sabemos que en una economía de la información el bien más escaso es la atención. Justamente esta es la labor que cumplen los buscadores: presentar en orden de relevancia los recursos relacionados a nuestro concepto (o tema) de búsqueda; siempre la idea es concentrar la información en clusters semánticos.

Así como existen foros, donde uno puede crear nuevos temas o seguir la conversación en temas ya creados, una arquitectura centrada en la relevancia debe proponer un diálogo que evite las ebras paralelas, los temas replicados y la información redundante y dispersa. Para lograr relevancia se debe centralizar la conversación y re-enebrar las ebras similares.

En cierta medida, se trata de centralizar los temas para constituirlos como espacio: espaciar los temas. Porque son precisamente los temas (issues) los que desencadenan los públicos a su alrededor2.

La Reversibilidad

Las reglas que definen los formatos de conversación deben basarse en principios simétricos de diálogo. Básicamente permitir la réplica como un argumento equivalente. Se trata de construir un espacio maleable por todos y que permita la emergencia de un discurso validado desde la participación.3

La dificultad que ofrece la validación de estos discursos emergentes es que “la gente” como institución no existe: siempre el discurso comenzará como una iniciativa “privada” que sólo podrá validarse mediante la masividad de la participación que convoque (las firmas que junte). Es en este sentido que la barrera de acceso a la creación de las temáticas debe ser mínima (ya basta con la barrera del acceso a la tecnología, a Internet y a la educación necesaria para desenvolverse en una plataforma semejante).

  1. Sir Thomas More. Of their Magistrates, Utopia []
  2. Jürgen Habermas sostiene que el concepto de “esfera pública” emerge desde el acto de comunicación —o conversación social— pero John Dewey sostiene que son precisamente los temas los que se instalan para construir públicos en torno a ellos. []
  3. Es lo que Iván Illich denomina convivial. []