Con el presente proyecto se pretenden establecer unas líneas de aprendizaje de la plataforma Node a través de un recorrido interactivo por sus principales mó­dulos, tanto propios como de terceras partes, con el que introducirse y asentar sus principios básicos de funcionamiento. A través de seis capítulos se quiere proporcionar al lector de una amplia visión de qué herramientas pone Node a su disposición y cómo debe usarlas para realizar sus propios desarrollos.

Cada uno de estos capítulos tratará uno o dos módulos muy relacionados entre sí, con la intención de que se cubran tópicos que vayan de menor complejidad a mayor. La estructura de dichos capítulos es siempre la misma:

  • un ligero repaso a los conceptos teóricos que hay detrás del módulo, general­mente desgranando una RFC (Request For Comments), con especial énfasis en aquellos que el API da opción a manejar.
  • un recorrido por el API del módulo no sintetizado, como pueda aparecer en la documentación de Node, sino explicando la relaciones intrínsecas entre los métodos, propiedades y eventos del módulo.
  • una propuesta de aplicación a desarrollar que esté basada en el módulo que se está tratando. Se procurará que la aplicación cubra la mayor parte posible de los conceptos que se destacaron en la introducción teórica.
  • el diseño propuesto al anterior problema, focalizando el desarrollo en aque­llos puntos que usan las herramientas que el módulo de Node proporciona para cumplir con los requisitos que la especificación anterior del problema impone.
  • una selección de fragmentos de código, cuyo dominio se considera obligato­rio para el conocimiento mínimo necesario del módulo, de tal manera que permitan desarrollar una aplicación con él. Estos fragmentos son los can­didatos para convertirse en Koans. Los Koans son la técnica de aprendizaje escogida para el proyecto. En los los párrafos siguientes se describirá qué son.

La selección de módulos que se ha realizado viene motivada esencialmente por un factor: Node está pensado para aplicaciones de red. Tiene sentido, por tanto, que sean todos aquellos relacionados con este hecho. Y no sólo dentro de los módulos nativos de la plataforma, sino también aquellos que su popularidad entre la comunidad de desarrolladores los ha hecho un estándar de facto. El proyecto comprenderá pues los siguientes capítulos:

  • Capítulo 3: módulos dgram y Buffer, o UDP como primera parada para ir cogiendo la dinámica de la plataforma.
  • Capítulo 4: módulos net y stream, para introducir con TCP un punto de complejidad en los protocolos de transporte.
  • Capítulo 5: módulo http, con el que subir un nivel en la pila de protocolos.
  • Capítulo 6: módulos Express, como la herramienta perfecta para la creación de aplicaciones web.
  • Capítulo 7: módulo IO, el paradigma de protocolo para las aplicacio­nes en tiempo real.

Como se ha comentado unas líneas atrás, el método elegido para el aprendizaje interactivo de la plataforma son los Koans, pero…¿qué son los Koans?

¿Qué son los Koans?

El término koan proviene de la filosofía Zen oriental. Es el nombre que se le da a un pequeño problema que un maestro plantea a su discípulo para evaluar su progreso. Suelen ser breves y escuetos y, a menudo, con apariencia trivial o absurda pero que, sin embargo, suponen para el discípulo un paso más en su camino hacia “el despertar” puesto que suponen para él realizar un esfuerzo para entender la doctrina.

Los koans en el ámbito informático fueron idea de Joe O’Brien y Jim Weirich, de EdgeCase, como forma de alcanzar “la iluminación” en el aprendizaje del lenguaje Ruby. Manteniendo la analogía con la filosofía Zen, los koans de Ruby son peque­ños trozos de código donde se sustituye alguna parte con unos guiones bajos ‘ ’, al estilo de los ejercicios de rellenar el hueco, que el alumno deberá cambiar por el código que piense que es el correcto para que el ejercicio ejecute sin errores. Para evaluar si lo que el alumno ha escrito en lugar de los ‘ ’ es correcto se emplean unos casos de prueba unitarios diseñados para cada koan.

Posteriormente los koans se han extendido a más lenguajes de programación, entre los que se incluyen JavaScript o Python.

La filosofía de los Koans que se han diseñado para Node es la misma que la que se ha presentado para los lenguajes de programación: fragmentos de código eva- luables mediante pruebas unitarias que marquen al alumno el camino a seguir para la correcta comprensión y asimilación de los aspectos relevantes necesa­rios para iniciarse en Node. Estos trozos de código se engloban en el marco de una aplicación concreta, con lo que no son independientes entre sí, sino que su resolución lleva al alumno a tener en sus manos un programa con completa fun­cionalidad donde entender mejor cuáles son los puntos clave más básicos cuando se programa con Node como tecnología de Servidor.

Tabla de Contenidos
Índice general
Índice de Tablas
Índice de Figuras

1. Introducción
1.1. ¿Qué son los Koans?
1.2. Guía de lectura
1.3. Conseguir el código fuente

2. Introducción a Node v0.8
2.1. ¿Qué es Node?
2.2. “Es una plataforma”
2.2.1. El proceso de arranque de Node
2.2.2. El formato CommonJS
2.2.3. Módulos disponibles en el core de Node
2.2.4. Módulos de terceras partes
2.3. “Construida encima del entorno de ejecución de JavaScript de Chrome”
2.3.1. El lenguaje JavaScript
2.3.2. El motor V8 de Google
2.4. “Fácil desarrollo de rápidas, escalables aplicaciones de red”
2.5. “Usa E/S no bloqueante dirigida por eventos”
2.5.1. El modelo de Concurrencia de Node
2.5.2. Arquitectura de Node
2.5.3. La clase EventEmitter
2.5.4. Postponiendo la ejecución de funciones
2.6. “Es ligero y eficiente” [1] 2.7. “Perfecto para aplicaciones en tiempo real data-intensive”
2.7.1. Tiempo real y Node
2.7.2. ¿Para qué es útil Node entonces?

3. Módulos Buffer y Dgram
3.1. Aspectos de UDP relevantes para Node
3.2. UDP en Node
3.3. Codificación de caracteres
3.4. Buffers en Javascript
3.5. Aplicación con Buffers y UDP
3.5.1. Descripción del problema
3.5.2. Diseño propuesto
3.5.2.1. El protocolo RTP
3.5.2.2. Descripción de la solución
3.6. Objetivos de los Koans
3.7. Preparación del entorno y ejecución de los Koans
3.8. Conclusión

4. Módulos Stream y Net
4.1. Aspectos de TCP relevantes para Node
4.2. Streams en Node
4.3. TCP en Node
4.4. Aplicación con Streams TCP
4.4.1. Descripción del problema
4.4.2. Diseño propuesto
4.5. Objetivos de los Koans
4.6. Preparación del entorno y ejecución de los Koans
4.7. Conclusión

5. Módulo Http
5.1. Aspectos de HTTP relevantes para Node
5.1.1. La parte del Cliente
5.1.2. La parte del Servidor
5.2. HTTP en Node
5.2.1. ServerRequest
5.2.2. ServerResponse
5.2.3. Clientes HTTP
5.2.4. ClientResponse
5.3. Aplicación con HTTP
5.3.1. Descripción del problema
5.3.2. Diseño propuesto
5.4. Objetivos de los Koans
5.5. Preparación del entorno y ejecución de los Koans
5.6. Conclusión

6. Express
6.1. Connect
6.2. Express
6.2.1. Request
6.2.2. Response
6.3. MongoDB
6.4. Aplicación de ejemplo
6.4.1. Clon de Twitter, objetivo 1: autenticación y control de sesiones
6.4.1.1. Descripción del Objetivo
6.4.1.2. Diseño propuesto al Objetivo implementado con Express
6.4.1.3. Objetivos de los Koans
6.4.1.4. Preparación del entorno y ejecución de los Koans
6.4.2. Clon de Twitter, objetivo 2: publicación de whizs y follow y unfollow de otros usuarios
6.4.2.1. Descripción del Objetivo
6.4.2.2. Diseño propuesto al Objetivo implementado con Express
6.4.2.3. Objetivos de los Koans
6.5. Conclusión

7. Socket.IO
7.1. ¿Qué es Socket.IO?
7.1.1. “Socket.IO pretende hacer posible las aplicaciones en tiempo real”
7.1.2. “en cada navegador y dispositivo móvil”
7.1.3. “difuminando las diferencias entre los diferentes mecanismos de transporte”
7.2. Usando Socket.IO
7.2.1. Servidor
7.2.2. Cliente [2] 7.3. Aplicación con Socket.IO
7.3.1. Descripción del juego
7.3.2. Objetivos perseguidos
7.3.3. Diseño propuesto
7.3.4. Implementación con Socket.IO
7.4. Objetivos de los Koans
7.5. Preparación del entorno y ejecución de los Koans
7.6. Conclusión

8. Conclusión y trabajos futuros
A. Listados
A.1. Módulos dgram y Buffer
A.2. Módulos net y Stream
A.3. Módulo http
A.4. Módulo Express
A.5. Módulo Socket.IO

Fuente: Arturo Muñoz de la Torre Monzón