Programando la música de Star Wars con Gibber

Como comenté en un mi última entrada, estoy aprendiendo con mis hijas a programar música, dibujos 2D y escenas 3D con Gibber. Para practicar un poco hemos buscado las notas del tema principal de Star Wars, y las hemos programado.

A continuación el código de la música de la Star Wars con Gibber:

Notation.on()
a = SoundFont('piano')
a.note.seq([
  "F3", "C4",
  "Bb3", "A3", "G3", "F4", "C4",
  "Bb3", "A3", "G3", "F4", "C4",
  "Bb3", "A3", "Bb3", "G3", "C3", "C3", "C3",
  "F3", "C4",
  "Bb3", "A3", "G3", "F4", "C4",
  "Bb3", "A3", "Bb3", "G3", "C3", "C3",
  "D3", "D3", "Bb3", "A3", "G3", "F3",
  "F3", "G3", "A3", "G3", "D3", "E3", "C3", "C3",
  "D3", "D3", "Bb3", "A3", "G3", "F3",
  "C4", "G3", "G3", "C3", "C3",
  "D3", "D3", "Bb3", "A3", "G3", "F3",
  "F3", "G3", "A3", "G3", "D3", "E3", "C4", "C4",
  "F4", "F3",
  "C4", "C3", "C3", "C3",
  "F3", "C4",
  "Bb3", "A3", "G3", "F4", "C4",
  "Bb3", "A3", "G3", "F4", "C4",
  "Bb3", "A3", "Bb3", "G3", "C3", "C3", "C3",
  "F3", "C4",
  "Bb3", "A3", "G3", "F4", "C4",
  "Bb3", "A3", "G3", "F4", "C4",
  "Bb3", "A3", "Bb3", "G3", "C3", "C3", "C3",
  "F2", "F2", "F2", "F2", "F2"
], [
  4/8, 4/8,
  2/24, 2/24, 2/24, 4/8, 2/8,
  2/24, 2/24, 2/24, 4/8, 2/8,
  2/24, 2/24, 2/24, 4/8, 2/24, 2/24, 2/24,
  4/8, 4/8,
  2/24, 2/24, 2/24, 4/8, 2/8,
  2/24, 2/24, 2/24, 4/8, 1/8, 1/8,
  3/8, 1/8, 1/8, 1/8, 1/8, 1/8,
  2/24, 2/24, 2/24, 1/8, 1/8, 2/8, 1/8, 1/8,
  3/8, 1/8, 1/8, 1/8, 1/8, 1/8,
  1/8, 1/8, 4/8, 1/8, 1/8,
  3/8, 1/8, 1/8, 1/8, 1/8, 1/8,
  2/24, 2/24, 2/24, 1/8, 1/8, 2/8, 1/8, 1/8,
  4/8, 4/8,
  6/8, 2/24, 2/24, 2/24,
  4/8, 4/8,
  2/24, 2/24, 2/24, 4/8, 2/8,
  2/24, 2/24, 2/24, 4/8, 2/8,
  2/24, 2/24, 2/24, 4/8, 2/24, 2/24, 2/24,
  4/8, 4/8,
  2/24, 2/24, 2/24, 4/8, 2/8,
  2/24, 2/24, 2/24, 4/8, 2/8,
  2/24, 2/24, 2/24, 4/8, 2/24, 2/24, 2/24,
  2/8, 2/24, 2/24, 2/24, 2/8
])

Y aquí os dejo un pequeño vídeo con el código ejecutándose:

Programando música, dibujos 2D y escenas 3D con Gibber

Tengo 2 hijas pequeñas y como propósito de inicio de año me propuse para más tiempo de calidad con ellas. Y que mejor para ello que encontrar algo que nos guste a ambos. Están los socorridos juegos de mesa y de cartas, pero a mi me gusta mucho programar, y a mis hijas a una le gusta mucho la música y a otra mucho las artes gráficas.

Buscando información sobre como juntar esos mundos, descubrí que existían las algorave, que es la abreviatura de "algorithmic rave" y que consiste en una rave (evento en donde la gente baila música electrónica) con la particularidad de que la música es generada a partir de algoritmos, a menudo utilizando técnicas de "live coding" o programación en directo.

Estuve probando distintos entornos y el que más me convenció fue Gibber, porque no hace falta instalar nada, se ejecuta desde el propio navegador y permite generar tanto música como dibujos 2D y escenas 3D.

A continuación un pequeño código de ejemplo:

a = Drums('x*ox*xo-')
  .pitch.seq( [.5,1,2,4], 1/8 )
  .pan.seq( [-1,0,1], 1/8 )
  .shuffle.seq( null, 1 )

a = Cube()
  .rotation.seq( [.5,1,2,4], 1/8 )
  .position.x.seq( [-50,0,50], 1/8 )
  .scale.seq( [.5,1,2,4], 1/8 )

Y aquí os dejo un pequeño vídeo con el código ejecutándose:

Bibliografía:
- Manual de Gibber.
- Referencia de Gibber.

Listado de los vídeos de las charlas de Codemotion mediante web scraping con Puppeteer

El año pasado dí una charla en el Codemotion sobre cómo desarrollar aplicaciones descentralizadas en la Blockchain de Etheruem. El caso es que hace poco han subido los vídeos de las charlas del evento a la web de Codemotion. El problema es que no me gusta como han organizado la información.

Primero tienes que acceder a la página de ponentes del Codemotion:

Y luego tienes que acceder a la página de un ponente del Codemotion:

Y luego tienes que hacer scroll para ver el título, el resumen y el vídeo de la charla que ha dado el ponente:

Pero además, si no estás logueado, no te aparece la charla:

Así que me he entretenido haciendo un script para juntar toda la información relevante de las charlas de Codemotion con un enlace a los vídeos en un solo fichero. He utilizado Puppeteer, que es una librería de NodeJS que proporciona una API de alto nivel para controlar Chrome y con la cual podemos hacer web scraping.

Para ejecutar el script tienes que, primero clonar mi repositorio codemotion-talks:

git clone git@github.com:asanzdiego/codemotion-talks.git

Luego instalar NodeJS, y luego Puppeteer con el siguiente comando:

npm install puppeteer

Y por último ejecutar el siguiente comando poniendo el mail y la contraseña de vuestro usuario de la página de Codemotion:

node codemotion-talks.js YOUR_EMAIL YOUR_CODEMOTION_PASSWORD

El proceso tarda un ratito y os saldrá algo así:

Y al final del proceso obtendréis un bonito fichero codemotion-talks.html con toda la información relevante (nombre del ponente, nombre de la charla, resumen de la charla, idioma de la charla, nivel de la charla, y un enlace al vídeo de la misma):

Sois libres de forkear y modificar este proyecto a vuestro gusto :-)

Mis propósitos para el 2019

Como otros años, y después de hacer mi retrospectiva del 2018, toca ahora plasmar mis propósitos para este 2019, que son muy parecidos a los que me propuse hace un año, con algún que otro cambio:

1. Primero, quiero pasar más tiempo con mi familia y mis amigos, sobre todo quiero pasar más tiempo de calidad con mi mujer y mis hijas. Tengo que seguir con la progresión del año pasado.

2. Segundo, quiero seguir intentando tener una vida más saludable. Este propósito tiene otros propósitos secundarios:

1. Reducir el consumo de azúcares, grasas y alcohol.
2. Aumentar el consumo de frutas, verduras y agua.
3. Dormir al menos 7 horas diarias.
4. Andar al menos 5 kilómetros diarios.
5. Hacer deporte (correr/gimnasio) al menos 2 veces por semana.
6. Bajar mi peso al menos 2 kilos y no volverlos a coger.

Este año daré como superado el propósito si al menos cumplo 4 de los 6 propósitos secundarios.

3. Tercero, quiero mejorar mi nivel de inglés. Este propósito tiene otros propósitos secundarios:

1. Añadir sitios de habla inglesa a mi RSS.
2. Seguir a personalidades de habla inglesa en mi Twitter.
3. Hacer al menos tres lecciones de Duolingo a la semana.
4. Ver al menos dos horas de series y/o películas en inglés a la semana.
5. Ver al menos una charla técnica en inglés cada dos semanas.
6. Traducir al menos un artículo del inglés al español al mes.
7. Escribir al menos un post en inglés cada dos meses.

Daré como superado el propósito si al menos cumplo 4 de los 7 propósitos secundarios.

4. Cuarto, quiero seguir dando lo mejor de mi como Asesor Técnico Docente en el servicio TIC de la Dirección General de Infrastucturas y Servicios de la Consejería de Educación e Investigación de la Comunidad de Madrid.

5. Quinto, quiero seguir ayudado a mi gran amigo Fernando con Pronoide. Tengo la impresión que este 2019 va a ser un año todavía mejor que el 2018 para Pronoide.

6. Sexto, quiero seguir colaborando con la Universidad de Alcalá como profesor de algún Máster.

7. Séptimo, me encantaría seguir siendo ponente, como otros años, ya sea en algún meetup, en el t3chfest, en el OpenExpo, en el Codemotion, en el CommitConf, o dando algún curso como formador técnico.

8. Octavo, quiero mejorar mi política de compartir. Quiero escribir al menos 12 entradas en mi Blog, crear al menos 2 repositorios en mi GitHub y subir al menos 2 presentaciones en mi SlideShare.

9. Noveno, quiero estar pendiente de posibles oportunidades profesionales. Estoy muy a gusto donde estoy, y estoy muy a gusto con lo que hago, pero creo que estoy un poco estancado. Estoy en la mitad de mi vida profesional, y creo que me quedan todavía saltos que dar.

10. Y por último, quiero escribir al menos un post cada cuatro meses con el seguimiento de mis propósitos.

Espero seguir con la tendencia del año pasado y conseguir, si no son todos, la mayor parte de mis propósitos.

Retrospectiva del 2018

Como otros años, me gusta hacer una retrospectiva chequeando los propósitos que me marqué a principio de año y ver cuales de ellos he conseguido:

1. Primero, tener una vida más saludable. Este propósito tenía varios objetivos secundarios:

1. Reducir el consumo de azúcares, grasas y alcohol. A medias.
2. Aumentar el consumo de frutas, verduras y agua. A medias.
3. Dormir al menos 7 horas diarias. Conseguido.
4. Andar al menos 5 kilómetros diarios. Conseguido.
5. Hacer deporte (correr/nadar) al menos 2 veces por semana. A medias.
6. Bajar mi peso al menos 2 kilos y no volverlos a coger. Conseguido.

A medias. Aunque he hecho avances y estoy en la buena senda tengo que seguir mejorando este aspecto de mi vida.

2. Segundo, seguir dando lo mejor de mi como Asesor Técnico Docente en el servicio TIC de la Dirección Genaral de Infrastucturas y Servicios de la Consejería de Educación e Innovación de la Comunidad de Madrid.

Conseguido. Creo que he cumplido de sobra mis cometidos. Aquí querría dar las gracias a todos mis compañeros y sobre todo a mi jefe José Quirino.

3. Tercero, entregar en tiempo y forma mi Proyecto Fin de Máster del Máster Universitario en Ingeniería del Software para la Web en el que me matriculé en la Universidad de Alcalá. El proyecto ha consistido en el desarrollo de una aplicación descentralizada de gestión de expedientes académicos en la blockchain de Ethereum.

Conseguido. Saqué un 10, y admitieron mi paper en el Congreso ATICA y lo adjuntaron en el libro de actas.

4. Cuarto, seguir ayudado a mi gran amigo Fernando con Pronoide.

Conseguido. Creo que, como años anteriores, he sido un buen consejero para Fernado. La verdad es que mi implicación en Pronoide este año ha aumentado para bien con respecto al año pasado. Creo que el 2019 va a ser un buen año para Pronoide.

5. Quinto, seguir colaborando con la Universidad de Alcalá como profesor de algún Máster.

Conseguido. Desde aquí querría dar las gracias a Miguel Ángel Sicilia y a Jorge Vallet por darme la oportunidad de colaborar como profesor en varios Másters.

6. Sexto, seguir siendo ponente, como otros años, ya sea en algún meetup, en el t3chfest, en el OpenExpo, en el Codemotion, en el CommitConf, o dando algún curso como formador técnico.

Conseguido. He sido ponente en el t3chfest, en el Codemotion y en el CommitConf, en este último con un taller y una charla:

• Taller de 0 a 100 de Bash Shell Scripting y AWK [GitHub] en el t3chfest.
• Charla de 0 a 100 con Bash Shell Scripting y AWK [GitHub] en el CommitConf.
• Taller de desarrollo de aplicaciones descentralizadas en la Blockchain de Ethereum [GitHub] en el CommitConf.
• Charla de cómo desarrollar aplicaciones descentralizadas en la Blockchain de Etheruem [GitHub] en el Codemotion.

7. Séptimo, buscar un nuevo líder que me sustituya en Hackathon Lovers.

Conseguido. Desde abril tenemos a Karina como nueva lideresa en Hackathon Lovers y lo está haciendo muy bien.

8. Octavo, mejorar mi política de compartir.

Conseguido. He escrito 15 entradas en mi Blog, he compartido varios repositorios nuevos en mi GitHub y subido varias presentaciones en mi SlideShare.

9. Noveno, quiero no empeorar mi nivel de inglés.

A medias. Si que he visto alguna serie en inglés, alguna película en inglés y alguna charla en inglés, pero creo que debería ser más constante.

10. Y por último, pero no por eso menos importante, pasar todavía más tiempo con mi familia y mis amigos, sobre todo quiero pasar más tiempo con mis hijas.

A medias. Creo que he mejorado con respecto al año anterior, pero como todos los años creo que debería pasar aún más tiempo con mis familiares y amigos, y sobre todo con mis hijas. A ver si en el 2019 esto mejora aún más.

RESUMEN:

Conseguido: 7 (70%) A medias: 3 (30%) No conseguido: 0 (0%)

Bueno, desde que hago retrospectivas, creo que este ha sido uno de mis mejores años. ʘ‿ʘ

La notación O grande con ejemplos en JavaScript

Después de mi anterior post sobre complejidad computacional, hoy voy a hablar de la notación O grande, que es una notación matemática que nos ayuda a describir el comportamiento de un algoritmo "al límite" en función de sus elementos de entrada N.

Algunos de los órdenes más utilizados en análisis de algoritmos, en orden creciente, están resumidos en la siguiente tabla:

notación	nombre
O(1)	constante
O(log n)	logarítmico
O(n)	lineal
O(n log n)	lineal logarítmico
O(n^2)	cuadrático
O(2^n)	exponencial
O(n!)	factorial

A continuación tenéis un vídeo en inglés en dónde se explica la notación O grande y como saber el orden de un algorítmo estudiando su código con reglas sencillas. Luego yo después muestro varios ejemplos de algoritmos de distintos tipos de orden.

Ejemplo de un algoritmo de orden O(1)

Imaginemos un programa que dado un número N, saca dicho número por pantalla. Para simular que el programa hace "algo", antes de sacar dicho número por pantalla, vamos a hacer que llame a una función llamada "retraso" que cree un array con los 999.999 primeros números naturales.

function retraso() {
    let max = 999999;
    let array = new Array(max);
    for (let index = 0; index < array.length; index++) {
        array[index] = index;
    }
}

function ejecutar(n) {
    let inicio = new Date();
    retraso();
    console.log(n);
    let fin = new Date();
    let miliseconds = fin.getTime() - inicio.getTime();
    console.log(miliseconds + " miliseconds");
}

ejecutar(10);
ejecutar(1000);
ejecutar(100000);
ejecutar(10000000);

El programa lo ejecutamos para N=10, N=1.000, N=100.000 y N=10.000.000, sacando por pantalla en cada caso el número de milisegundos que ha tardado en ejecutarse.

10
11 miliseconds
1000
5 miliseconds
100000
6 miliseconds
10000000
5 miliseconds

Como vemos, este algoritmo es de orden O(1), constante, pues da igual el número de entrada, siempre va a tardar más o menos lo mismo en ejecutarse.

Ejemplo de un algoritmo de orden O(log N)

Imaginemos el mismo programa de antes, solo que ahora guarda en un array la división de N por 2, y luego la división del resultado obtenido por 2, y así sucesivamente hasta que el resultado sea menor que 1. Para simular que el programa hace "algo", antes de asignar un número al array, vamos a hacer que llame a una función llamada "retraso" que cree un array con los 999.999 primeros números naturales.

function retraso() {
    let max = 999999;
    let array = new Array(max);
    for (let index = 0; index < array.length; index++) {
        array[index] = index;
    }
}

function ejecutar(n) {
    let inicio = new Date();
    let array = [];
    let resultado = n;
    while (resultado > 1) {
        retraso();
        resultado = resultado / 2;
        array.push(resultado);
    }
    let fin = new Date();
    let miliseconds = fin.getTime() - inicio.getTime();
    console.log(n);
    console.log(miliseconds + " miliseconds");
}

ejecutar(10);
ejecutar(1000);
ejecutar(100000);
ejecutar(10000000);

El programa lo ejecutamos para N=10, N=1.000, N=100.000 y N=10.000.000, sacando por pantalla en cada caso el número de milisegundos que ha tardado en ejecutarse.

10
22 miliseconds
1000
47 miliseconds
100000
84 miliseconds
10000000
127 miliseconds

Como vemos, este algoritmo es de orden O(log N), logarítmico, pues el tiempo de ejecución depende logarítmicamente del número de entrada (si multiplicamos N por 100 el tiempo de ejecución aproximadamente solo se duplica).

Ejemplo de un algoritmo de orden O(N)

Imaginemos el mismo programa de antes, solo que ahora guarda un array con los N primeros números naturales. Para simular que el programa hace "algo", antes de asignar un número al array, vamos a hacer que llame a una función llamada "retraso" que cree un array con los 999.999 primeros números naturales.

function retraso() {
    let max = 999999;
    let array = new Array(max);
    for (let index = 0; index < array.length; index++) {
        array[index] = index;
    }
}

function ejecutar(n) {
    let inicio = new Date();
    let array = new Array(n);
    for (let index = 0; index < n; index++) {
        retraso();
        array[index] = index;
    }
    let fin = new Date();
    let miliseconds = fin.getTime() - inicio.getTime();
    console.log(n);
    console.log(miliseconds + " miliseconds");
}

ejecutar(1);
ejecutar(10);
ejecutar(100);
ejecutar(1000);

El programa lo ejecutamos para N=1, N=10, N=100 y N=1.0000, sacando por pantalla en cada caso el número de milisegundos que ha tardado en ejecutarse.

1
7 miliseconds
10
49 miliseconds
100
584 miliseconds
1000
6076 miliseconds

Como vemos, este algoritmo es de orden O(N), lineal, pues el tiempo de ejecución depende directamente del número de entrada (si multiplicamos N por 10 el tiempo de ejecución también se multiplica aproximadamente por 10).

Ejemplo de un algoritmo de orden O(N^2)

Imaginemos el mismo programa de antes, solo que ahora guarda un array con todas las combinaciones de multiplicar todos los números naturales igual o menor que N. Para simular que el programa hace "algo", antes de asignar un número al array, vamos a hacer que llame a una función llamada "retraso" que cree un array con los 999.999 primeros números naturales.

function retraso() {
    let max = 999999;
    let array = new Array(max);
    for (let index = 0; index < array.length; index++) {
        array[index] = index;
    }
}

function ejecutar(n) {
    let inicio = new Date();
    let array = new Array(n*n);
    for (let i = 0; i <= n; i++) {
        for (let j = 0; j <= n; j++) {
            retraso();
            array.push(i*j);
        }
    }
    let fin = new Date();
    let miliseconds = fin.getTime() - inicio.getTime();
    console.log(n);
    console.log(miliseconds + " miliseconds");
}

ejecutar(2);
ejecutar(4);
ejecutar(8);
ejecutar(16);

El programa lo ejecutamos para N=2, N=4, N=8 y N=16, sacando por pantalla en cada caso el número de milisegundos que ha tardado en ejecutarse.

2
46 miliseconds
4
125 miliseconds
8
487 miliseconds
16
1702 miliseconds

Como vemos, este algoritmo es de orden O(N^2), cuadrático, pues el tiempo de ejecución depende cuadráticamente del número de entrada (si multiplicamos N por 2 el tiempo de ejecución se multiplica aproximadamente por casi 4).

Introducción a la complejidad computacional

Fuente: https://www.flickr.com/photos/andres-colmen/2539473895

La teoría de la complejidad computacional trata de clasificar los problemas que pueden, o no pueden ser resueltos con una cantidad determinada de recursos (tiempo y memoria).

A grandes rasgos, la teoría de la complejidad computacional trata de clasificar los problemas que pueden, o no pueden ser resueltos por una computadora.

Máquina de Turing

Una máquina de Turing es un dispositivo teórico que manipula símbolos sobre una tira de cinta de acuerdo a una tabla de reglas.

El estudio de sus propiedades abstractas ha servido de base para mucho desarrollo teórico en las ciencias de la computación y en la teoría de la complejidad.

A continuación tenéis un vídeo en dónde se explica qué es una máquina de Turing.

Algoritmo

Un algoritmo es un conjunto prescrito de instrucciones o reglas bien definidas, ordenadas y finitas que permiten llevar a cabo una actividad mediante pasos sucesivos que no generen dudas a quien deba hacer dicha actividad.​

Dados un estado inicial y una entrada, siguiendo los pasos sucesivos se llega a un estado final.

A continuación tenéis un vídeo en dónde se explica qué es un algoritmo.

Tiempos polinómicos

Cuando el tiempo de ejecución de un algoritmo se puede expresar usando una fórmula polinómica, se dice que dicho problema se puede resolver en un tiempo polinómico.

Estos son "buenos" algoritmos.

Tiempos exponenciales

Cuando el tiempo de ejecución de un algoritmo no se puede expresar usando una fórmula polinómica, se dice que dicho problema es de tiempo exponencial.

Cuando un problema solo se puede resolver mediante algoritmos exponenciales, se dice que es intratable.

Problemas de clase NP

La clase de complejidad NP consta de los problemas "verificables" en tiempo polinómico, es decir, dada una posible solución, esta se puede verificar en un tiempo polinómico por una máquina de Turing.

A grandes rasgos, NP corresponde a la clase de problemas que, de manera realista, se pueden verificar con una computadora.

Problemas de clase P

La clase de complejidad P contiene a aquellos problemas que se pueden resolver en tiempo polinómico por una máquina de Turing.

A grandes rasgos, P corresponde a la clase de problemas que, de manera realista, se pueden resolver con una computadora.

Los problemas de clase P siempre son de clase NP (si lo podemos resolver en tiempo polinómico, también podemos verificarlo en tiempo polinómico).

Problemas NP-Completo

La clase de complejidad NP-Completo consta de los problemas "verificables" en tiempo polinómico, pero que no se ha encontrado un algoritmo que pueda resolver dicho problema en tiempo polinómico por una máquina de Turing.

A grandes rasgos, NP-Completo corresponde a la clase de problemas que se pueden verificar de forma sencilla, pero solo se pueden resolver por fuerza bruta.

Los problemas de clase NP-Completo siempre son de clase NP.

El problema ¿P=NP?

La pregunta ¿P=NP? es uno de los 7 problemas del milenio.

Si P=NP, cualquier problema polinómicamente verificable (NP) se podría resolver polinómicamente (P).

Esto quiere decir que podríamos pues resolver los problemas de clase NP-Completo de forma polinómica.

A continuación tenéis un vídeo en dónde se explica qué es eso del problema P versus NP.

En mi siguiente artículo hablo sobre la notación O grande con ejemplos en JavaScript.

Instalacíón y configuración de MySql Server en Ubuntu 18.04

MySQL Server es un servidor de gestión de bases de datos relacionales con licencia GPL (Software Libre).

Para instalar el servidor MySQL en un Ubuntu hay que ejecutar el siguiente comando:

sudo apt install mysql-server

Para configurar el servidor de MySQL lo mejor es ejecutar el siguiente comando:

sudo mysql_secure_installation

El comando anterior irá haciendo distintas preguntas de seguridad. Iremos presionando "Y" y luego "ENTER" para aceptar los valores predeterminados. Salvo cuando nos pregunta por la contraseña de root del servidor MySQL (que podemos poner la misma que la del Ubuntu).

Luego tenemos que cambiar el método de autenticación del usuario root del servidor MySQL, así que nos conectamos con el siguiente comando:

sudo mysql

Cambiamos el método de autenticación del usuario root del servidor MySQL de "auth_socket" a "mysql_native_password" con el siguiente comando (hay que poner el password que hemos puesto antes):

mysql > ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY 'password';

Luego recargamos los privilegios del servidor de MySQL con el siguiente comando:

mysql > FLUSH PRIVILEGES

Por último nos desconectamos de MySQL Server con el siguiente comando:

mysql > exit

Cómo cambiar el tamaño del disco duro virtual de Virtual Box

En este post explico como cambiar el tamaño del disco duro virtual de Virtual Box:

1.- Apagar la máquina virtual.

2.- Seleccionar la máquina virtual y pinchar sobre "Configuración".

3.- Luego ir a la sección "Almacenamiento".

4.- Seleccionar el archivo VDI para ver la ruta física del sistema host en donde está guardado como se se indica en la imagen del post.

En mi caso, como trabajo con Ubuntu como sistema host, la ruta es "/home/adolfo/VirtualBox VMS/Ubuntu/", pero supongo que en Windows será algo como "c:\Users\Usuario\VirtualBox VMS\Ubuntu\".

5.- Abrir una terminal. En Ubuntu se hace presionando "control + alt + t", pero en Windows tendrás que buscar el programa "cmd", o el programa "powershell".

6.- Con el comando "cd" que funciona tanto en Windows como en Linux, nos posicionamos en la carpeta del punto 4.

7.- Ejecutamos el siguiente comando:

VBoxManage modifyhd <ruta-archivo.vdi> --resize <tamaño-en-MB>

Ese comando redimensiona el disco duro virtual <ruta-archivo.vdi> a un tamaño de <tamaño-en-MB>.

¿Qué es Ethereum? ¿Qué es un smart contract o contrato inteligente? ¿Qué es una ÐApp o aplicación descentralizada?

Bitcoin ha sido la primera blockchain, pero desde su creación han aparecido muchas otras, cada una con diferentes características y protocolos. Una de las más importantes es Ethereum, creada por Vitalik Buterin en 2014.

¿Qué es Ethereum?

Es una blockchain pública que tiene la particularidad de permitir la ejecución de código y guardar estructuras de datos de forma descentralizada.

¿Cómo funciona Ethereum?

Ethereum funciona gracias a una máquina virtual llamada Ethereum Virtual Machine (EVM) que ejecuta bytecode de forma descentralizada. Los desarrolladores escriben programas en lenguajes de programación de alto nivel de tipo Turing completo, como Solidity. Estos programas, llamados Smarts Contracts, son compilados a dicho bytecode y subidos a la red de Ethereum, donde pueden ser ejecutados por cualquier persona. Toda ejecución dentro de la red de Ethereum consume un determinado Gas que tiene un coste que se paga en Ethers, la moneda de Ethereum, como incentivo a los mineros en forma de comisión.

¿Qué ventajas tiene Ethereum?

La ventaja de Ethereum con respecto a otras blockchains es que no es necesario construir una nueva blockchain para cada nueva aplicación pues Ethereum permite el desarrollo potencial de cualquier tipo de aplicación descentralizada. Actualmente existen distintas blockchains que, como Ethereum, permiten ejecutar código de forma descentralizada, pero Ethereum es la más madura de todas ellas.

¿Qué desventajas tiene Ethereum?

Ethereum, al igual que el resto de blockchains, si lo comparamos con el software “tradicional”, es lento, y tiene problemas de escalabilidad. Parte de estos problemas se solucionan utilizando blockchains privadas o mixtas. Actualmente todas las blockchains están intentando solucionar estos problemas, pero no parece que la solución vaya a llegar en breve.

¿Qué es un smart contract o contrato inteligente?

Un smart contract o contrato inteligente es un programa informático imparable e inmutable que se ejecuta de forma autónoma y descentralizada dentro de una blockchain.

¿Qué características tiene un smart contract o contrato inteligente?

Imparable

Una vez subido a una blockchain va a poder ejecutarse siempre, a no ser que haya sido programado para dejar de hacerlo. Un contrato inteligente no puede ser censurado por entidad alguna.

Inmutable

Una vez subido a una blockchain, tanto si funciona correctamente como si no, ya no se puede modificar. Si se quiere añadir una funcionalidad nueva es necesario subir un nuevo contrato.

Autónomo

Una vez subido a una blockchain no necesita ningún servidor para poder ser ejecutado pues lo hace en la propia blockchain.

Descentralizado

Una vez subido a una blockchain no necesita ningún tercero de confianza para ser interpretado, simplemente cada vez que se lance ejecutará las instrucciones en él programadas.

Confiable

Al estar almacenados en una blockchain, la trazabilidad de los datos generados por los contratos inteligentes es muy confiable.

¿Qué es una ÐApp o aplicación descentralizada?

Una ÐApp (se escribe con esta Ð extraña) o aplicación descentralizada es una aplicación que no depende de un sistema central si no que interactúa con uno o varios contratos inteligentes alojados en una blockchain.

¿Qué diferencias existen entre una ÐApp o aplicación descentralizada y una aplicación web tradicional?

La arquitectura de una aplicación web tradicional consiste en:

1. por un lado, el front-end, que se corresponde con la interfaz gráfica de la aplicación, que se suele programar con HTML, CSS y JavaScript y que se suele ejecutar en un navegador web;
   
2. y por otro lado, el back-end, que se corresponde con la parte del servidor, osea con:
   
   1. los servicios web, que se suelen programar con Java, .NET, PHP, Python, Ruby, etc.;
      
   2. y las bases de datos en donde se guardan los datos.
      

La arquitectura de una aplicación descentralizada se diferencia en que en este caso el back-end se corresponde con la blockchain en donde:

1. se ejecutan los contratos inteligentes que serían como los servicios web tradicionales;
   
2. y se guardan los datos en forma de transacciones en la propia blockchain.
   

Imagen. Arquitecturas de una aplicación web tradicional y de una ÐApp o aplicación descentralizada.

Ver también

• ¿Qué es Bitcoin? ¿Qué es una Blockchain? ¿Qué es el minado? ¿Qué mecanismos de consenso existen? ¿Qué tipos de blockchain existen?

Bibliografía

• Alexey Malanov (2017). 6 mitos sobre la cadena de bloques y Bitcoin: desmintiendo la efectividad de la tecnología.
• Igor Korsakov (2018). Awesome Smart Contracts.
• miethereum (2018). Smart Contracts o Contratos Inteligentes.
• miethereum (2018). ÐApps.
• Vitalik Buterin (2014). Una nueva generación de Contratos Inteligentes y Plataforma para Aplicaciones Descentralizada.