Introducción a

FLOQQ

https://slid.es/alexfernandez/node-js-floqq

Quién soy

Requisitos

Manejo de varios navegadores (Chrome, Firefox)

Conocimientos básicos de HTML

Conocimientos básicos de JavaScript

Familiaridad con algún tipo de servidor web

(Java, PHP, Apache)

Manejo básico de consola Unix / DOS

Sesiones

1. Introducción a node.js
2. Sesión práctica: hola, mundo (http)
3. Introducción al manejo de eventos
4. Sesión práctica: hola, mundo (sockets)
5. Pruebas asíncronas con node.js
6. Sesión práctica: pruebas de sockets
7. Continuaciones y callbacks
8. Sesión práctica: desmontando callbacks
9. npm: Node Package Manager
10. Sesión práctica: paquetes

Node.js

Una introducción amable

Breve historia de Node.js

Creado por Ryan Dahl (2009)

Tres generaciones

Procesos: CGI, PHP core

Hilos: Apache MTM, Java Servlets

Eventos: nginx, node.js

Modelo de ejecución

Asíncrono

No bloqueante

Dirigido por eventos

Servidores similares:

Python: Tornado, Twisted

Ruby: EventMachine

Java: Akka

Node.js es rápido

¿Pero cómo de rápido?

No para correr código secuencial

... pero sí en ejecución concurrente

Sólo un hilo en ejecución (sin hilos)

Multi-proceso usando el módulo cluster

Node.js es muy escalable

Node.js es muy lineal

Historia de Éxito: PayPal

Página de Resumen de Cuentas

2 ingenieros durante 4 meses

Desarrollado dos veces más rápido que la versión Java

33% menos código, 40% menos ficheros

Dos veces más peticiones por segundo

Tiempos de respuesta un 35% más rápidos

Actualmente migrando toda su infraestructura

Historia de Éxito: LinkedIn

Backend de apps móviles (2011)

Migración desde Ruby on Rails

De 15 instancias a 4 con node.js

El doble de carga que Ruby on Rails

Actualmente migrando toda su infraestructura

Fuente: VentureBeat

Historia de éxito: MediaSmart Mobile

Plataforma inicial: un ingeniero durante un año

Plataforma actual: tres ingenieros durante otro año

Sirve anuncios en móvil para campañas performance

Aguanta 20K peticiones/segundo (al menos)

Escala a 30 servidores (que sepamos)

Latencia < 80 ms

Eventos

Asincronía al poder

Emisor de eventos

Clase EventEmitter

Emite evento data:

emitter.emit('data', data);

Para recibir el evento data:

emitter.on('data', function(data) {
    console.log('Data: %s', data);
});

API de recepción

emitter.on(event, function(data) {}); 

Registra un listener para un evento

emitter.once(event, function(data) {}); 

Registra un listener para una sola vez

emitter.removeListener(event, listener); 

Elimina un listener

emitter.removeAllListeners([event]); 

La temible fuga de memoria

(node) warning: possible EventEmitter memory leak detected. 11 listeners added. Use emitter.setMaxListeners() to increase limit.

Ocurre cuando se añaden listeners a un emisor

y no se eliminan

Ejemplo: reutilización de conexiones en un servidor

Solución: al terminar cada petición eliminar listener

emitter.removeListener('event', listener);

Emitiendo Eventos

Podemos crear nuestros propios EventEmitters:

var events = require('events');
var util = require('util');
function MyEmitter() {
    events.EventEmitter.call(this);
    http.createServer(function (request, response) {
        this.emit('request', request);
        res.end('Hello World\n');
    }).listen(1337, '127.0.0.1', function() {
        this.emit('init');
    });
}
util.inherits(LimitsUpdater, events.EventEmitter);
var emitter = new MyEmitter();
emitter.on('init', function() {
    console.log('Server started');
});

Esto nos permite gestionar eventos en lugar de callbacks

Pruebas Asíncronas

¿Quién automatiza al automatizador?

Tipos de pruebas

Pruebas unitarias

Pruebas de integración /  de sistemas

Pruebas de carga

Pruebas automáticas: ¡las mejores!

Pruebas de código asíncrono

No basta con correr el código y ver el resultado

Requieren una librería especial

Veremos cómo usar testing

Librería especializada

Éxito y fracaso

testing.failure("Failed to do something", callback); 

Da la prueba por fallida con un mensaje

testing.success("Well done!", callback); 

Da la prueba por buena con un mensaje

Aserciones

Para comprobar que un valor contiene lo que se espera

testing.assert(value, "Error in value", callback); 

La variable value debe ser cierta (true o un objeto)

testing.assertEquals(sum(2, 2), 4, "Wrong sum", callback); 

Ejecución asíncrona

testing sigue la convención habitual de node para callbacks:

doSomething(function(error, result) {
    if (error) {
        console.error('Could not do something: ' + error);
        return;
    }
    ....
});

El error contiene algo sólo si la función falló

testing.check(error, "There is an error", callback); 

Ejemplo de test

Comprobar que la función doSomethingAsync() no da error

y devuelve el valor 5

function testAsync(callback) {
    doSomethingAsync(function(error, result) {
        testing.check(error, 'Could not do something', callback);
        testing.assertEquals(result, 5, 'Invalid result', callback);
        testing.success(callback);
    });
}

Control

testing.run([testFirst, testSecond], timeout, callback); 

Corre las pruebas testFirst() y testSecond()

testing.show(results); 

Muestra el resultado de las pruebas

Uso habitual:

// run tests if invoked directly
if (__filename == process.argv[1])
{
    testing.run([testFirst, testSecond], testing.show);
}

¡Automatiza!

Diseña un API de control

Arranca y para el sistema usando el API

Tests auto-contenidos: limpia al terminar

Tres reglas básicas:

• Un único botón
  
• Haz los fallos visibles
  
• Sin intervención humana
  

Continuaciones

Continuaciones

Concepto de programación funcional

CPS: Continuation-passing Style

¡También conocidas como callbacks!

El estado pasa como parámetros y clausuras

Ejemplo: servidor sockets

var net = require('net');
var port = 1702;
var server = net.createServer(function(connection) {
    console.log('Connection to %s open', port);
    connection.write('Hello?\r\n');
    connection.on('data', function(data) {
        if (String(data).trim() != 'hello) {
            connection.write('ERROR\r\n');
        } else {
            connection.end('world\r\n');
            console.log('Connection to %s closed', port);
        }
    });
});
server.listen(port);

Infierno de las Callbacks

La temida pirámide de callbacks

Infinitas continuaciones anidadas

Abuso de lambdas (funciones anónimas)

Difícil de seguir, depurar y refactorizar

Soluciones Sencillas

Usar funciones con nombre

Crear un objeto con funciones con nombre

Las clausuras se convierten en atributos

Usar async: async.waterfall()

Usar eventos: EventEmitter

Otros modelos

Promesas

Programación reactiva

NPM

Node Package Manager

Anatomía de un paquete (o módulo)

Fichero Readme: README.md

Definición: package.json

Punto de entrada: index.js

Código: lib/

Documentación: doc/

Comandos NPM

• npm install: instala uno o más paquetes
  
• npm install -g: instalación global
  
• npm update: actualiza uno o más paquetes
  
• npm remove: elimina un paquete
  
• npm test: corre las pruebas
  

Resolución de directorios

Local:

            node_modules
         ../node_modules
      ../../node_modules
   ...
$HOME/node_modules
          ./node_modules

Global:

{prefix}/lib/node_modules

donde {prefix} suele ser /usr/local

aNATOMía de un package.json

{
    "name": "simplecached",
    "version": "0.0.1",
    "description": "Simplified memcached server.",
    "contributors": ["Alex Fernández <alexfernandeznpm@gmail.com>"],
    "license": "MIT",
    "repository": {
        "type": "git",
        "url": "https://github.com/alexfernandez/simplecached"
    },
    "dependencies": {
        "testing": "1.2.x"
    },
    "keywords" : ["simplecached", "didactic", "memcached", "caching"],
    "scripts": {
        "test": "node test.js"
    },
    "private": "false"
}

¡Gracias!