The Pitts Circus, la primera película financiada con Ethereum

Todos los días me sorprendo de las cosas que son capaces de hacer la gente con Ethereum. Uno de las primeras apliaciones que surgieron fue el crowdfunding distribuido. ¿Te imaginas un Kickstarter P2P? Pues con Ethereum es posible implementarlo.

Siguiendo estas ideas surge The Pitts Circus, la primera película financiada con Ethereum.

La película

Se trata de una cienta de terror-comedia que incorpora las habilidades, talento cómico y naturaleza única de una familia de circo real de Australia. La familia circense Pitts ha estado de gira por los cinco continentes con su espectáculo. Cecil Pitt también es un músico consumado, forma parte de la banda musical Barkers Vale Brothers. Él se hará cargo de la banda sonora de la película ya que participó en todos los episodios de Karnydale (otro proyecto de los productores de la cinta) La familia contará con: los dos padres, un chico de 11 años, una niña de 6 años y un niño de 1 año. Disfruta de este cuento de hadas circense, ambientado en el remoto oeste de Australia y Suiza, con acróbatas, payasos, un sacerdote, niños diabólicos y caníbales.

¿Cómo funciona?

Inicialmente se han creado 666 acciones del proyecto, estas se compran vía Ethereum y el smart contract asociado se encargará de repartirnos los beneficios que genere la película (si los hubiera) durante 20 años. Para evitar situaciones similares a lo ocurrido con la DAO, el crowdfunding no se basa exclusivamente en Ethereum sino que hay un respaldo legal en Suiza. La compañía productora es aKenEvilThing, una empresa fundada en 2014 en Suiza con varios proyectos anteriores.

Si quiéres colaborar con la financiación del proyecto lo único que tienes que hacer es enviar una cantidad determinada de Ether según el número de acciones que quieras comprar (1 acción = 10 ETH) a la dirección que aparece en su página web.

Ahora mismo el equipo está de rodaje y se espera que para finales de 2017 ya pueda presentarse a algunos festivales de cine. Algunos actores confirmados aparte de la familia Pitts son: Carlos Henriquez y Matto Kämpf.

 

Entrevista con Tony Caradonna

Pregunta: Tony, ¿puedes contarnos un poco acerca de la película?
Tony Caradonna: “The Pitts Circus es una película de horror-comedia ficticia protagonizada por los “Pitts”; una familia real de un circo a las afueras de Australia, justo donde las primeras escenas están siendo filmadas antes de viajar a Suiza para terminar el rodaje. En 2018 la película independiente se presentará en festivales de cine antes de su lanzamiento en cines selectos en todo el mundo y por Video-on-Demand. Lo que realmente nos emociona es que la película es la primera del mundo que se financia completamente con Ethereum “.
Pregunta: Como realizaron esto? Y por qué decidieron financiar el film con Ethereum?
Tony Caradonna: “La película es financiada por 666 acciones de crowdfunded, con un costo por acción de diez Ethereum (que son aproximadamente 97 dólares americanos para el momento en que se escribió esta nota). Los accionistas recibirán el 50% de los ingresos de la película por un período de 20 años garantizados por contratos inteligentes: contratos auto ejecutables basados en leyes suizas que utilizan protocolos informáticos basados en la cadena de bloques de Ethereum para verificar y hacer cumplir las cláusulas acordadas por sus firmantes. Esto se traduce en un acuerdo de contrato más rápido y seguro para todos. El Pitts Circus es uno de los primeros proyectos rentables en el mundo real que está conectado a la cadena de bloques, por lo que a mi parecer hace que sea una gran manera de mostrar a la gente común la propuesta de valor en blockchain y moneda digital”.
Pregunta: ¿Qué más podemos esperar de esta película y la compañía productora?
Tony Caradonna: “Queremos ver más participación de la comunidad en la producción de películas, desde el casting hasta el argumento. Hemos desarrollado nuestro propio activo accionario para ayudar a conseguir lo que llamamos EMV-coin (Ethereum Movie Coin). Nuestras monedas EMV se distribuirán gratuitamente a todos nuestros accionistas, con una ICO planeada para adquirir monedas adicionales en el futuro y que podría aumentar la participación de los consumidores en futuras producciones. Las monedas permitirán a los consumidores agregar o votar por propuestas, nuevos contenidos y la dirección estratégica de futuras producciones. Estamos creando un caso real de negocios a escala mundial que muestra lo que es posible hacer con la plataforma de Ethereum “.
Pregunta: ¿Entonces la moneda EMV es un activo que nos da la posibilidad de decidir sobre futuras películas permitiéndonos votar para evitar historias exageradas y finales que dan paso a nuevas experiencias en pantalla? ¿Las monedas EMV también benefician el ROI de la película?
Tony Caradonna: “Sí, exactamente. Este enfoque de toma de decisiones de producción significa que los consumidores ven lo que quieren ver. Los contribuyentes pueden intercambiar nuevas ideas con la posibilidad de que la comunidad vote para que se produzca alguna de ellas. Esto equivale a menores costos de producción para la película que sugiera la comunidad, y mayores ventas, ya que las ideas han sido previamente validadas por el consumidor. La combinación de presupuestos de producción más bajos con mayores ingresos recompensa a los inversionistas con mejores beneficios. Los poseedores de monedas EMV se benefician del contenido que ellos mismos ayudan a generar”.
Pregunta: ¿Qué puedes ver para la industria cinematográfica en el futuro después del lanzamiento de The Pitts Circus?
Tony Caradonna: “Puedo prever que muchas películas se producirán con un modelo similar al nuestro a través de la contribución de la comunidad. Los presupuestos de producción más bajos que estas películas exigen llevarán a que muchas nuevas ideas puedan llegar a la pantalla grande, y que cualquiera pueda aparecer en los créditos de una película. Si Ethereum continúa en su actual avance, espero que el modelo de producción en comunidad de EMV se vuelva muy popular, con muchas personas deseando comprar monedas EMV en los intercambios para también poder participar en el modelo que hemos creado. Esto resultaría muy favorable para el precio en que se cotice en el mercado el EMV “.
Pregunta: ¿Otros planes para el futuro?
Tony Caradonna: “Hemos realizado varias alianzas de negocio con compañías relacionadas al área de las criptodivisas que ayudarán a apoyar la red de monedas EMV incluyendo: Ledger Wallet, Trezor y Ether Card para que el intercambio de monedas de EMV y Ether sea seguro y simple, COVAL para cifrar Bitcoin y Ether en archivos de audio con su plataforma ‘Vocal’. Estas alianzas permitirán la colocación de productos digitales en el film”.

Sobre Tony:

Tony Caradonna tiene un Master en Física y Filosofía. Financió sus estudios haciendo espectáculos como comediante y artista de circo. Estuvo de gira con varios circos en todo el mundo. Allí conoció a Ken Fanning, un director y artista de circo. También conoció a la Familia Pitts, una Familia Australiana de Circo. Su primer encuentro fue en una gira con otro circo australiano 2000/2001. Han trabajado juntos regularmente en varias ocasiones desde entonces. Actualmente, el financiamiento del Swiss National Language Cooperation Arts funding ya está concedido y aún está pendiente un Financiamiento del Swiss National Film Arts

loading...

¿Está usted de broma Sr. Feynman?

Acabo de leer un libro, un señor libro, uno de los que más me han gustado recientemente. Y ha sido un placer leerlo.

Se trata de ¿Está usted de broma Sr. Feynman? y es una especie de autobiografía de la vida del físico Richard Feynman. El libro se estructura en anécdotas que va contando que si bien suelen tener un elemento de inicio cronologicamente ordenado con el resto, cada anécdota puede estructurarse de forma diferente.

El libro es muy divertido y derrocha originalidad. Es un claro ejemplo de por qué prefiero los libros de no ficción, ya que superan a la ficción y por mucho.

La vida de Richard Feynman, uno de los grandes físicos del siglo XX, es una completa inspiración. Una invitación a ser curioso, a no tener miedo al qué dirán, a dejar de preocuparse y a disfrutar de las cosas de la vida.

Algunas anécdotas interesantes:

  • La apertura de cajas fuertes en Los Alamos
  • Cabrear a la censura de Los Alamos
  • Introducirse en el mundo de la pintura y llegar a realizar un cuadro para un burdel
  • Tocar la frigideira en una banda de Río de Janeiro
  • Recibir un premio Nobel
  • Dar un seminario de biología en Harvard (acabando justo él de terminar física)
  • Hablar en un idioma inventado en una actuación de scouts
  • Ligar en un local de carretera
  • Y muchas más

Mi más sincera recomendación. Yo ahora empiezo con la segunda parte ¿Qué te importa lo que piensen los demás?

 

¿Cómo borrar el historial?

Los sistemas informáticos actuales son auténticos engullidores de datos. Prácticamente cualquier acción que hagamos queda registrada. Muchas veces no nos importa demasiado y es incluso conveniente para nosotros pero a veces es necesario eliminar nuestros preciados datos.

Un rastro digital que dejamos cuando navegamos por la web es el historial. Como si fuese Pulgarcito, el navegador va guardando las páginas que hemos visitado y su orden. Esto puede ser interesante si queremos volver a visitar una página que visitamos hace unos días pero no nos acordamos de su nombre exacto.

El botón que da acceso al historial en Firefox. En otros navegadores es similar.
Como puedes observar es fácil saber en qué páginas has estado antes. Incluyendo redes sociales.

Pero no creas que el historial se guarda solo en los navegadores (Explorer, Chrome, Firefox, Opera, Safari, …) sino que ciertas webs también construyen sus propios historiales. YouTube o Google construyen sus propios historiales que construyen si el usuario ha iniciado sesión en el sistema.

Estos historiales también se pueden borrar como veremos más adelante.

No obstante, el navegador guarda otros datos de nuestra navegación. Cualquier persona que accediese a nuestro ordenador. Estos datos son las cookies (muy famosas por los insistentes avisos), la caché, los fomularios y las contraseñas que hayamos decidido guardar para nuestra comodidad.

Las cookies son necesarias para la navegación web tal como la entendemos hoy, sin embargo puede ser interesante borrarlas de forma regular. ¿Sabes por qué Google implementó la navegación privada en Chrome? Porque quería evitar que la gente borrase sus cookies cuando visitaban sitios de los que no querían dejar rastro en su ordenador. De ese modo Chrome seguía teniendo las cookies y los usuarios entran en un modo de incógnito. No obstante, eliminar las cookies de forma manual sigue siendo algo recomendable.

La caché la forman archivos (estilos, imágenes, fuentes,…) que se descargan la primera vez que visitamos una página. Estos se guardan en nuestro ordenador para que una vez accedamos de nuevo a esa web esta tarde menos en cargar. Es por ello que la caché está llena de archivos que se supone que nunca van a cambiar. Aun así, esta caché puede delatar las páginas que visitamos.

Para obtener más información los compañeros de http://borrar-historial.com se han pegado un currazo dando métodos efectivos y fiables de como borrar un historial.

 

Tutorial de Maud, motor de plantillas HTML para Rust

Seguimos aprendiendo en el blog sobre interesantes proyectos hechos para Rust. Ya hemos visto Iron, Piston y Neon. Hoy veremos Maud, un potente motor de plantillas que se centra en la eficiencia. Maud se compara a otras soluciones como Razor, ERB, Liquid,  Handlebars o Jade pero esta vez escribiremos nuestro HTML en Rust. ¿Locura? No, y de hecho funciona de forma bastante transparente. Vamos a verlo en acción

Comparativa de velocidad de diferentes motores. Maud es el más rápido (menos es mejor)

Instalando Maud

Maud usa plugins del compilador, una característica que a día de hoy no está activado ni en el canal estable ni el canal beta, solamente en el canal nightly. Para obtener una copia de Rust nightly lo ideal es usar Rustup.

Una vez hecho eso, creamos un nuevo proyecto y añadimos las dependencias de Maud al fichero Cargo.toml.

maud = "*"
maud_macros = "*"

Una simple plantilla

Ahora abrimos el archivo src/main.rs y vamos a empezar a usar Maud.

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

fn main(){
        let name = "Adrián";
        let markup = html!{
            p { "Hola, soy " (name) " y estoy usando Maud"}
        };
        println!("{}", markup.into_string());
}

La potencia de Maud se ve en la mega-macro html!. En esta macro escribiremos la plantilla que será compilada de forma nativa a Rust, lo que nos asegura una velocidad de ejecución excepcional. En este caso la salida será una etiqueta P de párrafo con la variable interpolada.

Simple, ¿no?

PreEscaped y otros elementos básicos

Por defecto en Maud todos el texto se convierte a HTML seguro. Es decir, no se pueden introducir etiquetas nuevas en el texto. Si por alguna razón necesitásemos añadir etiquetas nuevas podemos usar PreEscaped, que no realiza esta transformación de seguridad. Veamos el siguiente código:

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

use maud::PreEscaped;

fn main(){
        let name = "Adrián";
        let markup = html!{
                p { "Hola, soy " (name) " y estoy usando Maud" }
                p { "<h5>Esto no funcionará</h5>" }
                p { (PreEscaped("<h5>Esto sí funcionará</h5>")) }
        };
        println!("{}", markup.into_string());
}

El primer H5 se convertirá a código HTML seguro, es decir, no añadirá la etiqueta, en cambio se verá h5 en la web. Por contra con PreEscaped se añadirá la etiqueta h5 tal cual.

Los elementos son muy fáciles de añadir en Maud y por lo general no deberías usar PreEscaped salvo contadas ocasiones. Veamos como añadir más etiquetas.

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

fn main(){
        let name = "Adrián";
        let markup = html!{
                p { "Hola, soy " (name) " y estoy usando Maud" }
                p {
                        "Si la montaña no viene a Mahoma"
                        br /
                        "Mahoma va la montaña"
                        small em "Atribuido a Francis Bacon"
                }
        };
        println!("{}", markup.into_string());
}

En este ejemplo vemos como las etiquetas que no llevan texto como BR o INPUT debemos cerrarlas con una barra. Por otro lado es posible aglutinar varios niveles de etiquetas en una sola línea ( SMALL->EM->Texto).

Atributos, clases e IDs

En Maud es posible asignar atributos también, usando literales o variables. Para los atributos de texto la sintaxis es muy parecida a HTML.

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

fn main(){
        let name = "Adrián";
        let amazon = "http://www.amazon.com";
        let markup = html!{
                p { "Hola, soy " (name) " y estoy usando Maud" }
                p {
                        "Este texto contiene enlaces a "
                        a href="http://www.google.com" "Google"
                        " y a "
                        a href=(amazon) "Amazon"
                }
        };
        println!("{}", markup.into_string());
}

Además existen en HTML atributos vacíos. Es decir, atributos que con su sola presencia basta y normalmente no llevan valor asignado.

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

fn main(){
        let name = "Adrián";
        let allow_editing = true;
        let markup = html!{
                p { "Hola, soy " (name) " y estoy usando Maud" }
                p contenteditable?[allow_editing] {
                }
        };
        println!("{}", markup.into_string());
}

En este caso el atributo contenteditable se añade si la variable allow_editing es true. Si queremos añadir atributos vacíos en cualquier circunstancia podemos simplemente quitar [allow_editing] y dejar p contenteditable? {}.

Los IDs y las clases se añaden usando la sintaxis esperable, puntos y almohadillas.

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

fn main(){
        let name = "Adrián";
        let markup = html!{
                p { "Hola, soy " (name) " y estoy usando Maud" }
                p.red.font-big#editor contenteditable? {
                }
        };
        println!("{}", markup.into_string());
}

Estructuras de control

Maud soporta las estructuras de control básicas de Rust, if/else, if/let, for in y match.

#![feature(plugin)]
#![plugin(maud_macros)]

extern crate maud;

fn main(){
        let loggedIn = false;
        let email = Some("mariscal@example.com");
        let fonts = ["Arial","Times New Roman","Verdana"];
        let markup = html!{
                @if loggedIn {
                        h1 { "Has iniciado sesión" }
                } @else {
                        h1 { "Por favor, inicia sesión primero" }
                }

                @if let Some(mail) = email {
                        p { "Su email es " (mail) }
                }
                ol {
                        @for font in &fonts {
                                li (font)
                        }
                }

        };
        println!("{}", markup.into_string());
}

Como vemos, Maud posee suficientes características para ser interesante. Maud además permite extender el motor para representar cualquier tipo de dato. Por defecto Maud mirá si está implementado std::fmt::Display pero si queremos añadir etiquetas extra este método no funcionará. En cambio si se implementa la trait maud::Render tendrás control total sobre como va a mostrar Maud las variables de ese tipo. En la crate maud_extras se encuentran implementaciones por ejemplo de Markdown para Maud.

Maud se integra además con web frameworks de Rust, en especial con Iron y con Rocket. Sin duda, una de mis crates favoritas.

Tutorial de Neon – Combina Node.js con Rust

Hoy en día muchas webs se diseñan con Node.js. Es una solución fantástica para respuestas rápidas pero numerosos benchmarks han demostrado que su rendimiento empeora en respuestas complejas. Estos mismos benchmarks recomiendan usar Java o .NET si preveemos que nuestra aplicación web va a generar respuestas complejas. Sin embargo renunciar a las ventajas de Node.js no es del agrado de muchos. Afortunadamente hay otra solución, usar Rust. Todo ello gracias a Neon.

Con Neon podemos generar módulos para Node.js que son escritos y compilados en Rust con las ventajas que supone desde un punto de vista de rendimiento y con la certeza de que en Rust la seguridad está garantizada.

Usando Neon puedes desarrollar tu aplicación en Node.js y si alguna parte tiene problemas de rendimiento sustituirla por su equivalente en Rust. Para el ejemplo voy a hacer un módulo de Markdown.

Instalando Neon

En primer lugar instalamos la herramienta de Neon desde npm.

npm install -g neon-cli

Una vez esté instalado podemos usar la herramienta de Neon para construir un esqueleto de módulo. Este esqueleto tendrá dos partes, un punto de entrada para Node.js y otro para Rust.

neon new PROYECTO

Hacemos un npm install como nos indica. Esto no solo obtendrá dependencias de Node.js sino que también se encargará de compilar el código nativo en Rust.

El código Node.js

Nuestro módulo contiene un archivo de Node.js que sirve de punto de entrada. Allí lo único que se debe hacer es cargar el módulo en Rust y hacer de pegamento. Puede ser algo tan simple como esto:

var addon = require("../native");

module.exports = addon; // se exportan todos los métodos del módulo nativo

Aunque si queremos añadir un tratamiento específico también es posible.

var addon = require("../native");

module.exports = {
    render: function(str){
        return addon.render(str);
    }
}

El código en Rust

Nos dirigimos ahora al archivo native/src/lib.rs. Ahí definimos los métodos nativos que va a tener el módulo. Lo hacemos a través de la macro register_module!.

register_module!(m,{
    m.export("render",render)
});

Ahora vamos a implementar la función render, que toma el texto en Markdown y lo devuelve en HTML.

fn render(call: Call) -> JsResult<JsString> {
    let scope = call.scope; // obtener el contexto
    let md: Handle<JsString> = try!(try!(call.arguments.require(scope,0)).check::<JsString>()); // obtener primer argumento como JsString. aquí puede hacerse tratamiento de fallos
    let string = md.value(); // Pasar JsString a String
    let html: String = markdown::to_html(&string); // usamos la crate markdown para renderizar a html
    Ok(JsString::new(scope, &html).unwrap()) // devolvemos un JsString con el contenido del HTML
}

Las funciones que interactuan con Node deben devolver un JsResult de un tipo JsXXX, por ejemplo, JsString, JsUndefined o JsInteger. Siempre aceptan un argumento llamado de tipo Call que nos da toda la información necesaria y que podemos usar para sacar argumentos. El scope o contexto es muy importante y lo deberemos usar en las funciones que interactúen con Node.

Código completo del fichero Rust

#[macro_use]
extern crate neon;
extern crate markdown;

use neon::vm::{Call, JsResult};
use neon::js::JsString;
use neon::mem::Handle;

fn render(call: Call) -> JsResult<JsString> {
    let scope = call.scope;
    let md: Handle<JsString> = try!(try!(call.arguments.require(scope,0)).check::<JsString>());
    let string = md.value();
    let html: String = markdown::to_html(&string);
    Ok(JsString::new(scope, &html).unwrap())
}

register_module!(m, {
    m.export("render", render)
});

Y no te olvides de añadir la dependencia markdown al fichero Cargo.toml.

Probándolo

Es muy fácil probarlo. Con el REPL de Node podemos probar partes del módulo antes de publicarlo a npm.

Para abrir el REPL ejecuta Node sin argumentos

node

E introduce línea por línea lo que quieras probar:

var md = require("./");
md.render("__Esto es Markdown__");

Verás el resultado por la pantalla:

Ahora que ya sabemos que funciona podemos publicarlo a npm si queremos con:

npm publish

Aunque recuerda revisar antes el fichero package.json para especificar la licencia y la descripción. Una vez esté publicado su uso en un nuevo proyecto será muy sencillo y de forma transparente se compilará el código nativo.

var md = require("rust-markdown");
var http = require('http');
var fs = require("fs");

var server = http.createServer((req, res) => {
  fs.readFile("index.md","utf-8",function(err,data){
     var html = md.render(data);
     res.statusCode = 200;
     res.setHeader('Content-Type', 'text/html');
     res.end(html);
  });
});

server.listen(8080, "127.0.0.1", () => {
  console.log("Server running");
});