Super Easy Template te ayuda a tener una página web en múltiples idiomas sin el tedioso paso de tener que compilar el código o usar ¨gettext()¨ en tu servidor, sino que es el cliente el que tiene la lógica de los templates en su navegador, y en consecuencia menos carga para tus servidores.

Super Easy Template te ayuda a crear templates en HTML donde en vez de colocar las palabras colocas placeholders a dichas palabras. Algo así:

<div class="basic">
  <h1>{{template_title}}</h1>
  <p>{{template_text}}</p>
</div>
<div class="flags"></div>

Tienes que tener un servidor web para poder poner en marcha el código.

Donde podemos ver los placeholders template_title y template_text. Para poner este template engine en marcha seguimos los siguientes pasos:

1. Descargar el código del repositorio: https://github.com/kuapay/Super-Easy-Template-Engine
2. Copia el contenido del repositorio completo al directorio base donde el servidor web tiene las páginas (en entornos linux suele ser /srv/www o /var/www).
3. Reinicia el servidor web.

Accede a la página web de tu servidor web (normalmente http://localhost/index.html) y verás la siguiente página en tu explorador.

Ahora ya tienes tu página web en marcha. Lo que tienes que hacer es empezar a cambiar los templates y rellenar los archivos que contienen los diccionarios de locales. Aquí vamos a ver el ejemplo para poner un template nuevo, con su diccionario y sus idiomas.

Primer template

El primer template que vamos a introducir lo vamos a llamar nuevo.mustache. El nombre del fichero debe acabar en .mustache por una sencilla razón, y es que SET es compatible con más template engines que queramos incorporarle. Por ahora hemos introducido nada más Mustache. Dentro del archivo, que lo vamos a introducir en:

$WWW_HOME/templates/nuevo.mustache

El contenido del archivo va a ser el siguiente:

<div class="basic">
  <h1>{{template_title}}</h1>
  <p>{{template_text}}</p>
  <p>{{template_another_text}}</p>
  <div class="flags"></div>
</div>

Ahora vamos a añadir en el archivo de diccionario el contenido de este nuevo template. Abrimos locales/en_US.locale y añadimos el nuevo template:

    "6":  "Saturday",
    "7":  "Sunday"
  },
  "basic.mustache": {
    "title":  "This is the title of the basic template",
    "text":   "Text that explains what is this template about"
  },
  "nuevo.mustache": {
    "title":  "Title of my new template",
    "text":   "My new template has this text that is beautiful.",
    "another_text":   "And this second paragraph explains how to make paragraphs."
  },
  "flags.mustache": {
    "change_language":  "Change the language:",
    "spanish":          "into spanish",
    "english":          "into english"
  }

Puedes ver que hemos añadido una sección JSON nueva al objeto del diccionario. Lo mismo hay que hacer en el diccionario locales/es_ES.locale donde vamos a añadir la misma sección, pero con el lenguaje apropiado:

    "6":  "Sabado",
    "7":  "Domingo"
  },
  "basic.mustache": {
    "title":  "Titulo del template basico",
    "text":   "Texto que compone el template basico"
  },
  "nuevo.mustache": {
    "title":  "Título de mi nuevo template",
    "text":   "Mi nuevo template tiene este texto tan molón.",
    "another_text":   "Y este segundo párrafo explica como hacer párrafos."
  },
  "flags.mustache": {
    "change_language":  "Cambia el idioma:",
    "spanish":          "a Castellano",
    "english":          "a Ingles"
  }

Ya tenemos el template con sus idiomas listos. Ahora vamos a poner todo en su sitio para poder ver este template en un link en el template principal. Para ello modificamos templates/basic.mustache:

<div class="basic">
  <h1>{{template_title}}</h1>
  <p>{{template_text}}</p>
  <a id="new_template_link" class="clickme">{{template_new_template_link}}</a>
</div>
<div class="flags"></div>

Y en el diccionario añadimos bajo la sección de basic.mustache las entradas para new_template_link, que en nuestro caso será “Mi nuevo template” y en inglés “Mi new template”.

Ahora queda la parte más cercana al Javascript, que es el indicar que cuando hagla click en el link, se muestre el nuevo template en la pantalla. Para esto, en el fichero javascripts/views/basic_view.js vamos a añadir las siguientes lineas:

BasicView.prototype.applyViewHandlers = function() {
  // Any action we want to make with this
  // template should be run here, as this
  // method is executed once the HTML code
  // is been injected in the page.

  // When clicking on the Link, the new template
  // will substitute this actual template (basic).
  var that = this;

  // Function.
  $('#new_template_link').click(function() {
    var mustache  = 'nuevo.mustache';
    var container = document.body;
    var content   = {};

    // Add the propper Locale from the locale file
    for(var i in app.locale[mustache]) {
      content['template_' + i] = app.locale[mustache][i];
    } 

    // let's clean the canvas to place
    // the new template.
    app.cleanCanvas();

    // Include the Template in the Web Page inside the
    // container we have specified.
    Templates.to_html(
      mustache,
      content,
      container,
      function() {
        that.applyViewHandlers();
      }
    );
  });

  app.views.flagsView = new FlagsView();
  app.views.flagsView.render();
};

Ya tenemos listo el template, las funciones y el texto en los diferentes idiomas. Todo esto se realizará en cliente, por lo que no tenemos por qué tener complejos servidores en Ruby, PHP o Java. Simplemente un servidor web hace las veces de servicio para estos templates. En el explorador del cliente, se cargará el diccionario del lenguaje seleccionado por el usuario, y en consecuencia los templates se rellenan con los tags adecuados.

¡Ya estamos listos para ver el contenido del nuevo template en nuestro servidor!

A colación de mi post anterior, he estado investigando en el mercado a ver qué es lo que hay por ahí que realmente merezca la pena. Es decir, me he dedicado a buscar sitios web que realmente piensan en la seguridad y la privacidad de los datos.

Os puedo adelantar qu

e tampoco he visto mucho, y lo poco que he visto no tiene vistas a mejorar. Por lo pronto os puedo presentar la lista de empresas en las que ahora mismo tengo mi desconfianza depositada:

• Apple, gracias a su magnífica estrategia de atención al cliente.
• Google, con su inmejorable gran hermano a gran escala.
• Sony, que tiene a los mejores hackers del mercado… muy entretenidos.

Además, he de agregar más historias sobre problemas de seguridad. A la lista se suma nuestro querido host de blogs, WordPress, que ha sufrido un ataque en toda regla en sus servicios de Automattic. NASA ha sufrido un ataque según un hacker rumano confirma. Y por último, que no último de los vulnerados, sino último de los que voy a mencionar, los servidores web de Stanford también han sido fruto de un ataque, pero esta vez de menos alcance. Sólo se han dedicado a insertar páginas web de software barato (pirata para los menos avezados).

Como podéis leer, el mundo de nuestros datos, Internet está siendo desmontado pieza por pieza. Y es que hay algunos que tienen la teoría de que esto es una señal del final del mundo, otros piensan que hay alguna industria con beneficios detrás de estos ataques. Pero al final solo podemos pensar en nuestro propio entorno y en nuestros datos.

Los datos que ponemos en las páginas web para usarlas, como Google GMail, Microsoft Hotmail, Apple Store, etc. son los mismos datos que puede usar cualquier empresa para sacar un perfil socio-demográfico de tí y cancelarte un servicio por considerarte cliente de riesgo. O los mismos que usan los hackers para usar tu ordenador como lanzadera de spam.

Así que me he propuesto hacer una lista de aquellas empresas que están en Internet y que al menos en su filosofía se preocupan por la privacidad de los datos que les doy. Aquí tenéis la reducida lista:

• Mi Banco: Según su política de privacidad, y según las leyes, no van a vender ni usar mi información para otra cosa que no sea servirme como banco.
• Mi Seguro médico: que su política de privacidad dice textualmente: ¨With your permission, Blue Shield may use the location information, such as GPS data, from your location-enabled product or service to provide you with information you have requested¨.
• Mi Mujer: que dice textualmente ¨¿A quién le va a interesar que yo hable de tí o de tu vida?¨

Es impresionante ver que por ejemplo te pidan permiso para usar tu información de geo-localización. ¡Eso no lo hace ni Apple!. Y que te garanticen que no van a usar tu información para hacerte campañas de marketing como hace mi banco.

Como podéis ver, poco me queda por ahí en los que yo confíe para dar mis datos. Obviamente sigo usando servicios como GMail, o como Skype para comunicarme. Pero nunca daría un número de tarjeta de crédito por esos medios, ni menos mi dirección de casa. Imagínate la de anuncios locales que empezarían a aparecerme en mis páginas. O la cantidad de cosas que querrían venderme para curar mi obsesión por los coches. En fin, la conclusión de este post es la siguiente: ten cuidado donde metes tus datos, porque las consecuencias pueden ser peor que los beneficios.

Hay algunas empresas que empiezan a promover un movimiento que se llama ¨Host Proof Storage¨, conocido anteriormente como ¨Host Proof Hosting¨ y que algunos llaman “Host Proof Application”. Del cual os hablaré más adelante cuando tenga tiempo para un post explicativo de esos con pasitos y con diagramas… Pero os dejo con la explicación básica.

Imaginar que se pudiera cifrar tus datos antes de ser enviados a Internet. De tal manera, que aquellos datos que quieres proteger, no pudieran ser abiertos por nadie más que tú y a quien le des permiso… interesante, ¿eh? Pues existe, y se hace ya. Algunas empresas ya están haciendo esto y además ganan dinero. Es decir, no ganan dinero por tener tus datos, como hacen todos los demás en Internet, sino que lo hacen por ofrecerte un servicio, sin tener la necesidad de tener tus datos en claro, es decir, analizables.

Por un lado tenemos a Sony, con su primer ataque reconocido, posteriormente, se descubre que no era su primer ataque, y finalmente, aquellos que somos jugadores de Play Station, tenemos que empezar a cambiar nuestros datos y dar de baja nuestras tarjetas asociadas.

Luego empezamos a oir los problemas que tiene Apple con sus móviles y la geolocalización. Nos están siguiendo a todas partes. Por lo que nos asustamos al saber que una gran corporación recopila tus datos geográficos incluso cuando no tienes tu móvil con geoposicionamiento activado. Apple por su parte, nos dice que esos datos no son para lo que pensamos, sino que lo hace ¨por nuestro bien¨.

Así pasamos al siguiente capítulo de la historia de la privacidad de los datos, descubrimos que RSA, empresa dedicada precisamente a la seguridad de los datos, ha recibido varios ataques de hackers, algunos con éxito.

Si seguimos indagando en los diferentes ataques con éxito y errores de seguridad de datos, vamos a enseñar uno todavía peor, la exposición de 3.5 millones de números de seguridad social en Texas, USA. O por ejemplo, que en la lista oficial de vulnerabilidades de alto riesgo de software, Microsoft sale más de 45 veces sobre el total de 60 listadas.

Y ahora es cuando nos pregutamos. ¿Qué está pasando?. Todos pensamos que Internet es aquella gran red donde nos podemos interconectar y todo es maravilloso. Donde la era de la privacidad se ha acabado, según nuestro amigo Mark, donde los gobiernos tienen que ser los que amenden los problemas de Google y donde puedes acceder a tu lista de búsquedas, inclusive las que usas en tu correo electrónico, aquí. Pero no nos damos cuenta que Internet solo lleva 15 años con nosotros y como toda tecnología, tenemos que aprender a usarla.

Los gobiernos están empezando a darse cuenta, y en Estados Unidos han lanzado la nueva ley de protección de la privacidad del usuario, que auna todas las preocupaciones que tenemos. Por ejemplo, va a poder forzar a las empresas a no seguir a los usuarios a través de sus servicios a menos que estos sean notificados por ello. También los usuarios pelean por su privacidad, como por ejemplo en Facebook.

El Estado de California en Estados Unidos ha lanzado una proposición de ley que hará que todas las redes sociales fuercen las opciones de privacidad en el registro del usuario nuevo y además cierre al máximo las opciones de todos los usuarios ya registrados.

Es decir, de esa red abierta donde todos estábamos conectados y felices, estamos pasando a una red de control y de limitaciones, donde de nuevo los gobiernos vuelven a tener poder.

Debemos recapacitar para saber hacia dónde queremos ir con esta tecnología, como lo hicimos con la energía nuclear cuando la descubrimos en su día. Donde no conocíamos realmente sus consecuencias hasta que pasó Chernóvil, o Hiroshima. No queremos que haya un Chernóvil en Internet, puesto que no sabemos qué consecuencias puede acarrearnos. Así que debemos ser más conscientes del uso que hacemos de la red. Tenemos que ser responsables de cómo usamos nuestros datos, y de a quién se los damos. Porque habrá veces que nunca los podamos tener de vuelta. Y otras muchas veces donde las consecuencias de haberlos dado nos seguirán durante muchos años.

Editado

He añadido la proposición de ley del estado de California al texto.

En primer lugar, necesitamos dos cosas básicas en nuestro Mac:

• VirtualBox: Gestor de maquinas virtuales, que lo podeis instalar aqui.
• Mac Ports: herramienta con la que podremos extraer el contenido que nos descarguemos de Microsoft, que os lo podeis instalar aqui.

Necesitamos VirtualBox dado que la manera oficial que nos provee Microsoft para probar las paginas en sus exploradores son imagenes completas de sus sistemas operativos, tanto Windows Vista como Windows XP.

Por otro lado, necesitamos Mac Ports para poder abrir los archivos donde residen estas imagenes de los sistemas operativos.

Una vez instalado Mac Ports, necesitamos ejecutar lo siguiente en una linea de comandos (terminal) en nuestro Mac:

$ sudo port install cabextract

Esto va a instalar el programa cabextract que necesitamos para extraer las imagenes de los EXE que nos vamos a descargar desde Microsoft.

Ahora vamos con los pasos necesarios para instalar las imagenes en nuestro Mac.

1. Descargar la imagen desde Microsoft

Aqui esta el link para descargar las imagenes que creamos convenientes:

http://www.microsoft.com/downloads/details.aspx?FamilyId=21EABB90-958F-4B64-B5F1-73D0A413C8EF&displaylang=en

No pasa nada porque sean EXE. Dado que tenemos cabextract para poder extraer lo necesario.

2. Extraer la imagen del EXE

Ejecuta lo siguiente:

$ cabextract fichero.exe

Donde fichero.exe es el fichero que nos hemos descargado.

Esto nos genera un fichero .vhd que es el que tenemos que transformar para que sea compatible con VirtualBox.

3. Transformar imagen al formato VirtualBox

Para hacerlo, tenemos que seguir ejecutando comandos en la consola, es decir, no cierres la consola todavia y ejecuta lo siguiente:

$ /Applications/Q.app/Contents/MacOS/qemu-img convert -O raw -f vpc "input.vhd" temp.bin 
$ VBoxManage convertdd temp.bin "output.vdi" 
$ rm temp.bin 
$ mv "output.vdi" ~/Library/VirtualBox/VDI/ 
$ VBoxManage modifyvdi "output.vdi" compact

Ahora ya tenemos la imagen preparada en VirtualBox para ser inicializada.

4. Iniciar la imagen desde VirtualBox

Abrimos VirtualBox desde Aplicaciones en nuestro Mac. Y vamos a crear una imagen nueva:

Hacemos click en new

E iniciamos el proceso de creación de imagen

Escogemos un nombre y el tipo de imagen. En nuestro caso hemos descargado la imagen de Windows XP con IE7 instalado.

E incorporamos la RAM que queremos dedicar a la maquina. En este caso le vamos a dar 512MB de RAM. Suficiente para lo que queremos de la maquina.

Incorporamos el disco virtual que hemos creado anteriormente en el paso 3 dentro de la imagen. Para ello, hacemos click en “Use Existing hard disk” y luego en el icono que aparece a la derecha de la selección.

Y buscamos nuestra imagen dentro del directorio donde la hemos dejado (el fichero VDI que hemos generado).

Ya tenemos la imagen preparada para ser iniciada y usada.

Tan solo tenemos que seleccionar la imagen de la lista de maquinas virtuales, y hacer click en start en el menu de VirtualBox. La maquina aparecera automaticamente como una ventana en nuestro escritorio.

De esta forma podremos probar nuestras paginas en Microsoft Internet Explorer 6, 7 y 8 de manera legal, dado que Microsoft provee estas imagenes precisamente para este proposito, y ademas de manera sencilla. Una vez que tienes una imagen, el resto es muy facil.

Pantalla de entrada:

Llegada al “inicio”:

Opciones del sistema:

Listado de archivos (ejemplo de /home/chronos):

Si queremos acceder a la consola de comandos propia (crosh) hay que pulsar Ctrl + Alt + T:

Si escribimos help obtenemos los comandos necesarios, entre ellos “shell”:

que nos lleva a la consola de Linux (finalmente!):

Y podemos ver que hay detras de ChromeOS:

Proximamente publicare un post sobre como compilar ChromeOS e iniciar una imagen con KVM.

Espero que os guste!

Por otro lado, si quisiéramos hacer lo mismo en Google Chrome, nos encontraríamos con el problema de que este explorador no cuenta ni con un API del estilo de XUL, ni tampoco con la manera de introducir nodos en el árbol DOM sin que sean vistos por la página en la que los introducimos.

éxtasis ácido camión

Existe de todas formas, una manera de poder resolver este problema en Google Chrome. He escrito un articulo en el que explico la manera más sencilla de hacerlo, y cómo podemos proteger nuestro contenido de la pagina en la que lo introducimos. Por medio de IFRAMES. He aquí el articulo:

http://www.borderstylo.com/posts/220-anonymous-content-injection-in-google-chrome

Con esta explicación podrás introducir contenido protegido sin el temor de que la pagina pueda extraerlo o modificarlo.

Ahora vamos a estudiar la manera en la que podemos conectar nuestro programa de Ruby a todos esos esclavos. La mayoría de las gemas que nos encontramos soportan múltiples esclavos. Pero la manera en la que se conectan es muy simple, y si nos encontramos en una situación de mucha carga, podemos llegar a tumbar toda la base de datos. Veamos el ejemplo de la gema Sequel.

Para configurar múltiples esclavos, tenemos que configurarla de la siguiente manera (codigo ejemplo de su documentación):

DB=Sequel.connect('mysql://master_server/database', \
    :servers=>{:read_only=>proc{|db| {:host=>db.get_slave_host}}})
  def DB.get_slave_host
    @current_host ||= -1
    "slave_server#{(@current_host+=1)%4}"
  end

Siendo master_server nuestro servidor maestro y slave_server#{(@current_host+=1)%4} nuestros esclavos.

Vamos a hacerlo más aleatorio:

DB=Sequel.connect('mysql://maestro/my_db', \
    :servers=>{:read_only=>proc{|db| {:host=>db.get_slave_host}}})

  def DB.get_slave_host
    slaves = [
      "esclavo_1",
      "esclavo_2",
      "esclavo_3",
      "esclavo_4",
      "esclavo_5",
      "esclavo_6"
    ]
    return slaves[rand(slaves.length - 1)]
  end

Ahora bien, viendo este código, podemos ver ya que la distribución de las conexiones va a ser equitativa, es decir, si tenemos 4 esclavos, cada uno de ellos va a recibir el mismo número de conexiones. Esto en un mundo ideal nos viene bien, pero no nos viene tan bien cuando tengamos alguno de los esclavos con más carga que los demás…

Vamos a darle una vuelta de tuerca. Vamos a tratar de comprobar el estado de los servidores antes de conectarnos, para saber si realmente queremos conectarnos a dicho servidor, o no…

DB=Sequel.connect("mysql://maestro/#{db_name}", \
    :servers=>{:read_only=>proc{|db| {:host=>db.get_slave_host}}})

  def DB.slaves_array
    slaves = [
      "esclavo_1",
      "esclavo_2",
      "esclavo_3",
      "esclavo_4",
      "esclavo_5",
      "esclavo_6"
    ]
    return slaves
  end

  def DB.get_slave_host
    tries = 0
    while tries <= DB.slaves_array.length
      slave = DB.get_slaves_array[rand(DB.get_slaves_array.length - 1)]
      return slave if DB.get_slave_delay <= 1
      tries += 1
    end
  end

  def DB.get_slave_delay(slave, db_name)
    begin
      DBSlave=Sequel.connect("mysql://#{slave}/#{db_name}")
      delay = DBSlave["SHOW SLAVE STATUS"]
      return delay[32].to_i
    rescue
      return 1000
    end
  end

Parte por parte.

Lo que este código hace es simplemente  comprobar si el esclavo al que nos vamos a conectar esta sin retrasos con respecto al maestro y ademas si nos podemos conectar. Para ello, cuando Sequel llame a db.get_slave_host lo que vamos a hacer es lo siguiente:

def DB.get_slave_host
    tries = 0
    while tries <= DB.slaves_array.length
      slave = DB.get_slaves_array[rand(DB.get_slaves_array.length - 1)]
      return slave if DB.get_slave_delay <= 1
      tries += 1
    end
  end

Vamos a sacar un esclavo de la lista de manera aleatoria:

slave = DB.get_slaves_array[rand(DB.get_slaves_array.length - 1)]

Y posteriormente vamos a tratar de conectarnos al esclavo y mirar su estado:

return slave if DB.get_slave_delay <= 1

Esto llama a la función que hemos definido:

def DB.get_slave_delay(slave, db_name)
    begin
      DBSlave=Sequel.connect("mysql://#{slave}/#{db_name}")
      delay = DBSlave["SHOW SLAVE STATUS"]
      return delay[32].to_i
    rescue
      return 1000
    end
  end

Esta función va a comprobar el estado del servidor. Si el esclavo tuviera algún problema, devolvería un retraso elevado (cuando los esclavos tienen mucha carga, suelen retrasarse con respecto a su maestro) o si no podemos conectar, entonces devolverá 1000, dando así un retraso muy elevado indicando que el servidor no esta disponible.

Nota: para que nuestro código pueda preguntar por el estado de los esclavos (“SHOW SLAVE STATUS”) necesitamos dar privilegios SUPER, REPLICATION CLIENT al usuario que hemos designado a nuestro programa para conectarse a los esclavos:

mysql> GRANT SUPER, REPLICATION CLIENT ON *.* TO 'user'@'domain' IDENTIFIED BY 'password'

En conclusión, si queremos que nuestro código soporte varios servidores esclavos y que compruebe la carga antes de cada conexión, debemos complicar la lógica de conexión a la hora de conectarnos a la base de datos. Las gemas como Sequel nos pueden ayudar a ello con abstracciones de conexión. Es muy sencillo hacer esta comprobación cada vez que nos conectamos. Pero como en todo, este método de comprobación no es escalable a grandes sistemas dado que cada vez que vamos a realizar una lectura, primero hacemos una conexión al esclavo para mirar su estado. Esto hace que la cantidad de conexiones se multiplique por dos.
Mi recomendación es que se trate de hacer un método híbrido donde en paralelo a este código, se compruebe el estado de los esclavos cada vez, y se modifiquen los pesos de cada esclavo dependiendo de dichas comprobaciones. Pero esto corresponde al siguiente post…

Hemos tenido que esperar por una razón de seguridad. Google Chrome 5 no nos permitía proteger los datos del usuario a la hora de posicionar los ‘slides’ en la pagina web. Pero la nueva versión lanzada, Google Chrome 6 (6.0.472 para ser más específicos) si que nos permite poner los ‘slides’ en la pagina con la seguridad de que nadie ni nada puede acceder a ellas, tal y como la extensión de Firefox está diseñada.

Para instalarte la extensión en Google Chrome, tienes que seguir los siguientes pasos:

1 Conseguir una cuenta de Glass

Si no tienes una cuenta de Glass no te preocupes, simplemente entra en:

http://www.writeonglass.com

Y en el recuadro de los códigos,

Escribe el código bamboo.

Sigue el proceso de registro y ya tienes una cuenta.

2 Entrar en Glass

Si ya tenias una cuenta, entonces lo que tienes que hacer es entrar en Glass. Simplemente, en http://www.writeonglass.com haz click en “Login”:

Introduce tu correo y contraseña de Glass y haz click en “Login”.

3 Descargar la Extensión

La extensión se encuentra en la sección de “Download” en el menú principal de arriba a la derecha:

Cuando pulses en “Download” re aparerecerá abajo a la izquierda las instrucciones para que te instales Glass:

Cuando hayas instalado Glass finalmente, te aparecerá un botón arriba a la derecha del navegador:

4 Disfrutar de Glass

Ya es hora de que pruebes la extensión para Chrome.  Cuando estes en una página de Internet que te interese compartir con alguien, haz click en el botón de Glass de tu navegador (o pulsa dos veces seguidas la tecla Control). Te aparecerá el siguiente menú:

Si hacemos click en “New Slide” (o pulsamos la tecla ‘N’) nos aparecerá en la página el Slide preparado para ser rellenado. Primero lo movemos a la parte de la página donde pensamos que tendrá más significado (puedes arrastrar el Slide a la posición que creas más conveniente).

Lo único que tenemos que hacer es rellenar el Slide con las personas a las que queremos remitir nuestro comentario:

Y a continuación, el mensaje que queremos enviar:

Y pulsar Post.

Y ya tenemos nuestro Slide compartido con Andrew. Recibirá una notificación en su propio Glass que le llevará a la página donde hemos situado nuestro Slide y se lo mostrará solamente a Andrew.

And if you want to join, go to:

www.writeonglass.com

And insert the code bamboo