Permalink

0

SmartComments, genera comentarios automáticamente al código JavaScript

Captura de pantalla 2014-04-15 a la(s) 10.16.21

Resumen

SmartComments es un módulo de Node.JS que puede ser útil a la hora de automatizar el proceso de generación de documentación, ahorrándonos horas de esfuerzo, y permitiendo que nuestra documentación siempre esté actualizada con los últimos cambios en el código fuente.

Introducción

Según estudios realizados por una prestigiosa agencia más del 90% de los programadores prefieren documentar el código fuente a escribirlo. ¿Qué?

Mi primera reacción fue pensar, ¿Es posible que el mundo haya cambiado tan rápido sin que me haya dado cuenta? Le pregunté a otros programadores del equipo si creían que el misterioso titular fuera cierto, y muy serios asintieron. Me inquietaba lo tedioso que resultaba para mí, comentar el código fuente que había escrito, sobre todo aquellas funciones que con solo leer el nombre ya se sabía lo que hacían. Además de tener que actualizar la documentación cada vez que se realizaba algún cambio.

¿Por qué yo no lo disfrutaba y otras personas si? De ese dilema salí sólo tras las carcajadas de mis compañeros de equipo… Uff, menos mal que era una broma.

 

Desarrollo

Muchos utilizamos herramientas como YUIDocs, o JSDocs, entre otras para generar la documentación de nuestros proyectos. Estas necesitan una serie de parámetros de entrada que deben ser escritos de manera explícita, por los programadores como por ejemplo:

/**

 * Descripción

 * @method Nombre de la función

 * @param Parámetro A

 * @param Parámetro B

 * @return Valor que retorna

 */

Este proceso puede resultar algo tedioso, sobre todo si tenemos en cuenta que cuando ocurre un cambio en alguno de estos parámetros, como el nombre de la función por ejemplo, tenemos que actualizar la documentación correspondiente.

También muchas veces hay partes de la documentación que pueden ser redundantes e innecesarias, es obvio que la función getNombre() devuelve el atributo nombre de la clase que la implemente, por tomar un ejemplo.

Estos fenómenos toman proporciones significativas cuando nos tenemos que hacer cargo de proyectos bastante avanzados y que tienen una escasa documentación.

Según @evangoer en la conferencia “Thinking of Documentation as Code”, al documentar el código fuente es útil hacerse 3 preguntas:

  • ¿Qué es lo que hace el código?
  • ¿Cómo es que lo hace?
  • ¿Por qué lo hace?

SmartComments, es una herramienta de código abierto escrita en JavaScript y corre sobre Node.js mediante la que se puede automatizar y acelerar así considerablemente el proceso de generación de documentación. Sobre todo respondiendo las preguntas (¿Qué? y ¿Cómo?). En la siguiente imagen se muestran las partes del ejemplo anterior que pueden ser generadas por SmartComments.

/**

 * Descripción

 * [@method Nombre_de_la_función] ——- SmartComments

 * [@param Parámetro_A] —————– SmartComments

 * [@param Parámetro_B] —————– SmartComments

 * [@return Valor_que_retorna] ———- SmartComments

 */

Básicamente solo tendríamos que poner la descripción de nuestra función. O alguna otra explicación más detallada de ser necesario.

Algunas de las funcionalidades de SmartComments son:

  • Generar la meta información necesaria para la generación de documentación a ficheros completos, de manera individual, o que se encuentren dentro de una jerarquía de directorios determinada.
  • Plugin para (sublime text), que da acceso a las funciones de la aplicación a través de este editor y que además permite generar comentarios a una selección de texto, lo cual es una funcionalidad bastante útil.
  • Personalización mediante plantillas para la generación de documentación a eventos, clases, atributos, entre otros. Y en dependencia del estilo de codificación de nuestra empresa o framework.
  • Versión online a modo de demostración que puede ser utilizada para la generación de meta información si no se desea instalar la aplicación.

Un caso de uso interesante planteado por Mr. Rich Kilgore es la utilización de SmartComments es el siguente:

  1. Se comentan se forma explícita solamente las funciones que son relevantes y se realizan los commit al control de versiones de esa manera.
  2. Usando una tarea de Grunt Se copia todo el código fuente a una carpeta temporal, y se ejecuta SmartComments para generar la meta información de las funciones que tienen menos relevancia.
  3. Luego se ejecuta YUIDocs, para generar la documentación API.

Esto ocurre de forma automatizada cada vez que se construye y se despliega el proyecto. La ventaja de esta filosofía de trabajo es que siempre la documentación API estará actualizada con los últimos cambios del código fuente.

Hay que señalar que SmartComments es solo una herramienta, y como herramienta al fin solo puede hacer (por ahora) una parte del proceso. Siempre existen casos que necesitan de la intervención humana. Sobre todo a la hora de querer expresar la verdadera semántica de determinado código.

 

Conclusiones

SmartComments es de mucha utilidad a en el proceso de generación de documentación, ya que mediante el mismo podemos ahorrarnos horas de esfuerzo, y fomentamos que nuestra documentación siempre esté actualizada con las últimas modificaciones en el código fuente. Si quieres colaborar con este proyecto open source, puedes hacerlo mediante github.

Sobre el Autor

Dariel Noel, desarrollador FrontEnd. Co-fundador de aquinama.com, thincss.github.io, SmartComments. Colaborador de web2021.blogspot.com.

Twitter: @dariel_noel

Blog Personal: darielnoel.github.io

GitHub: https://github.com/darielnoel

Permalink

0

Ocho de los más reconocidos programadores web en el JSConf Colombia 2013

jsconfcol13

Ocho de los más reconocidos programadores web del mundo, con experiencia en distintas técnicas y herramientas en el desarrollo de aplicaciones interactivas se reunirán por primera vez en Colombia. Se trata de un encuentro que se llevará a cabo en Medellín el 18 y 19 de Octubre.

JSConf.co 2013 es el primera conferencia de programadores de JavaScript en el que los desarrolladores nacionales tendrán la posibilidad de ponerse a la vanguardia mundial en la programación de aplicaciones web. Como todo en nuestro mundo, esta conferencia también está a tan sólo un clic! Basta con darse una vuelta por la página de la conferencia (http://jsconf.co) para inscribirse y conocer la red de oportunidades que ofrece JSConf.co.

JSConf es un evento internacional que se ha realizado durante cinco años en diferentes países del mundo y esta vez, con JSConf.co 2013, el evento por fin llega a Colombia. Uno de nuestras prioridades es poner en contacto a programadores experimentados con nuevas generaciones de ingenieros de software. El fin: compartir conocimiento y construir un ecosistema de emprendimiento tecnológico local, elemento crucial en un territorio donde se ha hecho mucho énfasis en la inversión de capital pero muy poco en el desarrollo técnico en general.

JSConf.co 2013 cuenta con el apoyo de Ruta N, una corporación fundada por la Alcaldía de Medellín, EPM y UNE, que tiene como principal objetivo promover el desarrollo de negocios innovadores vinculados con tecnología para mejorar la competitividad de la ciudad y la región en este aspecto.

Es importante resaltar que JSConf.co es un evento sin ánimo de lucro, organizado por voluntarios y cuyo único objetivo es el fortalecimiento de la comunidad de desarrollo web en Colombia. A su vez, se espera que este encuentro permita generar un vínculo permanente entre los programadores nacionales y los mejores en su campo alrededor del mundo, permitiendo que el país se ponga a la cabeza en el desarrollo de aplicaciones web en la región.

Dentro de los conferencistas internacionales para JSConf.co 2013 se encuentra:  

Angelina Fabbro, actualmente técnica de Firefox OS en Mozilla. Fabbro es reconocida por su basta experiencia programando tanto en JavaScript como ObjectiveC, conocimiento que le permite ser profesora en la Universidad de San Francisco (SFU) y mentora en la iniciativa Ladies Learning Code. Es también experta en ciencias cognitivas y adicionalmente tiene un interés muy especial por elementos como Shadow DOM, Customs Elements y HTML Imports.

Glenn Block quien hace parte del equipo de ingenieros Windows Azure de Microsoft. En esta división, Block se encarga de que esta sea una plataforma sobresaliente en el desarrollo de tecnología Open Source al mismo tiempo que lidera el soporte en Node.js y Node SDK para Microsoft.

Charlie Robbins, otro reconocido ingeniero. Tras varios años de trabajar como consultor para Microsoft y varias instituciones financieras de renombre, Robbins decidió fundar la empresa Nodejitsu en el año 2010, la cual ofrece una plataforma como servicio (PaaS) para el despliegue de aplicaciones Node.js y un sistema de administración y configuración de infraestructura tecnológica llamado OpsMezzo.

Joe McCann, director de tecnología creativa en la empresa Mother, en Nueva York. McCann viene, desde hace un tiempo, utilizando su experiencia en móviles y multi- plataformas para ayudar a los clientes de su compañía en temas relacionados con publicidad, diseño experimental y digital. Este programador también lidera Circle Media, una iniciativa vinculada a Mother Ventures que se enfoca en recolección y análisis de métricas en tiempo real.

Guillermo Rauch. Rauch es CTO y cofundador de LearnBoost, una compañía con base en San Francisco enfocada en la optimización y administración automatizada de instituciones educativas. Además de esto, Guillermo Rauch es autor de Socket.IO y co-autor de Mongoose Node.js, un Object Data Manager para MongoDB.

Finalmente, JSConf.co también contará con las charlas del belga Mathias Bynens y los estadounidenses Sarah Chipps y James Halliday (substack).

Apoyan:

jsconf2013-auspiciantes

Permalink

0

Creando aplicaciones Node.js con TypeScript – Parte 2 #nodejs

Accediendo a la base de datos

Editamos el fichero db.ts y añadimos aquí el código que accede a nuestra base de datos MongoDB. Para ello, importamos el módulo de mongodb y creamos una instancia de la clase mongodb, establecemos la conexión con la base de datos y la abrimos:

import mongodb = module('mongodb');
var server = new mongodb.Server('localhost', 27017, {auto_reconnect: true}, {})
var db = new mongodb.Db('highscores', server);
db.open(function() {});

Una vez abierta la conexión, definimos una clase que describe los objetos que esperamos enviar/recibir de la colección “highscores”. Esta es una de las ventajas de utilizar TypeScript, que nos permite definir y trabajar con clases, e indicar el tipo de los parámetros de nuestras funciones.

export class Score {
    _id: string;
    user: string;
    score : number;
}

Ahora podremos definir las funciones que expone este módulo. Veremos que hay ciertos elementos nuevos con respecto a una definición en JavaScript.

export function getScores(callback: (scores: Score[]) => void) {

    db.collection('scores', function(error, scores_collection) {
        if(error) { console.error(error); return; }
        scores_collection.find({}).toArray(function(error, scoresobj) {
           if(error) { console.error(error); return; }
           callback(scoresobj);
        });
        
    });
}

La primera la vemos en los parámetros, estamos indicando que tendremos un callback, que será de tipo void (esto es, que no devuelve nada) la cual recibirá una lista de objetos de tipo Score (la clase que acabamos de definir). Este callback será la función anónima que acabamos de definir en el módulo index:

(scores) => {
        res.render('index', { title: 'Highscores', scores: scores })
}

El resto de una función es la típica que provee el módulo de mongoDB. Pero ya podemos ver la facilidad con la que podríamos cambiar el servidor al que nos conectamos o incluso el repositorio de datos…

Definiendo las vistas

Gracias a JadeJS podemos cambiar el aspecto de la UI de una forma muy sencilla. En nuestro caso sólo vamos a definir una vista en la que mostrar la lista de puntuaciones. Para ello creamos 2 ficheros: layout.jade para tener unos elementos comunes e index.jade para mostrar la lista:

layout.jade

!!!
html
  head
    title ImageBoard
    link(rel='stylesheet', href='http://cachedcommons.org/cache/960/0.0.0/stylesheets/960.css')
    link(rel='stylesheet', href='/stylesheets/style.css')
  body
    #header.container_12
      script(src='http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.7.min.js')
    #container.container_12!= body

index.jade
h1= title
p Welcome to #{title}

ul
- each score in scores
  li
    b= score.user + " " + score.score

index.jade

h1= title
p Welcome to #{title}

ul
- each score in scores
  li
    b= score.user + " " + score.score

No es intención de este artículo explicar cómo utilizar Jade, pero vemos que podemos recorrer de una forma muy sencilla una lista de elementos, en nuestro caso la clasificación de puntuaciones, y mostrarlas en una página.

Si desde SublimeText compilamos el fichero app.ts podremos ver cómo se generan todos los ficheros JavaScript que serán los que utilice nuestra aplicación. Gracias a la Build Definition que hemos creado anteriormente, no es necesario hacerlo por cada fichero .ts, sino que se hace automáticamente para todos los que necesitamos. Y ya podemos arrancar la aplicación:

node app.js

y abrimos un navegador para ver el resultado:

tuto_3

Podemos ver que la página se renderiza correctamente pero no nos muestra ningún resultado, esto es normal puesto que no tenemos ningún registro en nuestra colección MongoDB. Vamos a hacer una página para insertar registros.

Añadiendo más funcionalidades

Siguiendo el mismo proceso que antes, lo primero que hacemos es modificar nuestro fichero de aplicación (app.ts) para añadir dos métodos nuevos, un GET que cargue un formulario y un POST para insertar los datos:

app.get('/scores/newscore', (req, res) => {
    routes.newscoreget(req, res);    
});

app.post('/scores/newscore', (req, res) => {
   routes.newscorepost(req, res);
});

Definimos los nuevos métodos en nuestro fichero index.ts:

export function newscoreget(req: express.ExpressServerRequest, res: express.ExpressServerResponse){
     res.render('newscore',{});   
};

export function newscorepost (req: express.ExpressServerRequest, res: express.ExpressServerResponse){
    var newscore = new db.Score()
    newscore.user = req.param('user');
    newscore.score = req.param('score');
     db.addScore(newscore, (r) => {
        res.redirect('/');
    });
};

Como vemos, el primero únicamente renderiza el formulario y es el segundo método el que llamará a nuestro módulo de acceso a datos. En este segundo método utilizamos un objeto de la clase Score que hemos definido en otro módulo, que será lo que pasemos como parámetro al método addScore. Veamos cómo implementamos este método:

export function addScore(newscore : Score, callback: (result: any)=> void){
    db.collection('scores', function(error, scores_collection) {
        if (error) { console.error(error); return; }
        scores_collection.insert({"user" : newscore.user, "score" : newscore.score },
            (error, result) => {
                if(error) { console.error(error); return; }
                callback(result);
            })
        });
}

Gracias a que utilizamos una clase de TypeScript, podemos ver sus propiedades cuando las necesitemos:

tuto_4

Y por último, creamos la vista newscore.jade con el formulario en el que añadimos el usuario y la puntuación:

form( method="post")
   div
       br
       div
           span.inputtitle User name :
           input(type="text", name="user")
       br
       div
           span.inputtitle Score :
           input(type="text", name="score")
       br
       #editScoreSubmit
           input.button(type="submit", value="Save Score")

Y modificamos nuestra vista principal para añadirle un botón que llame a nuestra recién creada vista:

h1= title
p Welcome to #{title}

ul
- each score in scores
  li
    b= score.user + " " + score.score
br
form( action="/scores/newscore/", method="get")
    div
        #newScoreSubmit
            input.button(type="submit", value="New Score")

Volvemos a compilar el fichero app.ts y arrancamos la aplicación, si todo ha ido bien ya podremos acceder al formulario para añadir puntuaciones:

tuto_5Y ver el resultado en la página principal:

tuto_6

RESUMIENDO

Este pequeño ejemplo nos ha servido para ver cómo se puede hacer una aplicación web con NodeJS y TypeScript con una buena estructura, el código bien organizado y siguiendo el patrón MVC. Esto nos permite que, si la aplicación es muy grande, el trabajo se pueda repartir entre diferentes personas/grupos de manera muy sencilla. Además, podemos tener definidos módulos de prueba (fakes) que simulen funcionalidades que no están desarrolladas.

Autor de éste Artículo

Pablo Bouzada, desarrollador especializado en .NET y otras tecnologías Microsoft. Consultor en Pasiona Consulting y divulgador tecnológico en Techdencias. Colaborador de programandonet.com y otros grupos de usuarios de España.

Twitter: @pbousan

Slideshare: http://www.slideshare.net/pbousan

GitHub: https://github.com/pbousan?tab=repositories

Permalink

2

Creando aplicaciones Node.js con TypeScript – Parte 1 #nodejs

TypeScript es la respuesta de Microsoft a la necesidad de crear aplicaciones web robustas y mantenibles utilizando JavaScript. Esto lo consigue mediante:

  • Código más homogéneo y mantenible
  • Comprobación estática de tipos (opcional y de momento sólo con Visual Studio)
  • Object Oriented Programming: clases, herencia e interfaces
  • Separation of Concerns (SoC): mediante la organización del código en módulos que se pueden cargar de forma dinámica

En este link: http://programandonet.com/web/primeros-pasos-con-typescript/ tenéis un tutorial sobre las features básicas de TypeScript.

A diferencia de otros lenguajes que compilan JavaScript, como pueden ser Dart o CoffeScript, TypeScript es un superconjunto de JavaScript, por lo que en esencia es JavaScript.

tuto-1

Por tanto, si ya conocemos JavaScript, no tendremos ningún problema para utilizar TypeScript. La curva de aprendizaje de este nuevo lenguaje será realmente suave, pudiendo conseguir grandes resultados desde el principio. Además, al ser JavaScript, TypeScript nos permite seguir utilizando todas las librerías que conocemos hasta ahora (JQuery, Backbone, Knockout, …)

Hay que destacar también que TypeScript es un proyecto Open Source, y se puede descargar su código fuente (además de varios ejemplos) desde aquí: http://typescript.codeplex.com/ Actualmente se encuentra en la versión 0.8.3, y como podéis ver en este roadmap, en la versión final (1.0) estará completamente alineado con la versión 6 de ECMAScript, que traerá de serie alguna de las novedades que ya implementa TypeScript.

Existen varias formas de utilizar este nuevo lenguaje. La primera sería con proyectos creados con Visual Studio 2012 y el plugin de TypeScript. La segunda, que será sobre la que desarrollemos este artículo, es utilizar el paquete de Node.js y alguno de los IDEs que lo soporta (Sublime Text, Vim, Emacs,…). Para este artículo hemos decidido utilizar Sublime Text, ya que es uno de los que se integra mejor con TypeScript, exceptuando Visual Studio. En este link tenéis los pasos para utilizar TypeScript en Sublime Text tanto el syntax highlighter como la forma de crear una System Build que compile TypeScript:

Instalar el paquete de TypeScript para Node.js

npm install -g typescript

-   Para instalar el syntax highlighter, que te puedes descargar desde este link, sólo hace falta copiar el fichero typescript.tmplanguage en tu directorio de paquetes de Sublime Text.

-  Y sólo falta añadir un Build System para que compile los ficheros TypeScript. Para ello, abrimos Sublime Text, y en Tools –> Build System –> New Build System, añadir lo siguiente:

{
"selector": "source.ts",
"cmd": ["tsc.cmd", "$file"],
"file_regex": "^(.+?) \\((\\d+),(\\d+)\\): (.+)$"
}

Y con esto ya podemos compilar los fichero TypeScript (con extensión .ts) en sus correspondientes JavaScript simplemente presionando Ctrl+B

MANOS A LA OBRA

Vamos a desarrollar una aplicación muy básica: el sistema de puntuaciones de un juego. Que está basado uno de los ejemplos disponibles en el repositorio de TypeScript en Codeplex (http://www.typescriptlang.org/Samples/#ImageBoard), en la que utilizaremos una serie de paquetes Node que harán nuestro trabajo más sencillo:

  • ExpressJS para articular la estructura de la aplicación
  • Node-MongoDB para conectar con la base de datos
  • JadeJS como motor de gestión de vistas

Para este ejemplo es necesario, además de Node.js, tener MongoDB instalado, si no lo tenéis, podéis seguir estos pasos para instalar MondoDB en vuestro equipo.

Crearemos una estructura muy sencilla de directorios que nos permita tener las diferentes “capas” de la aplicación separadas, ya que usaremos una arquitectura MVC, tenéis disponible todo el código de este artículo en este repositorio de Github . A lo largo del artículo veremos las ventajas de tener los ficheros separados por funcionalidades de esta forma:

/node_modules
/public
– /stylesheets
/routes
– index.ts
/views
– index.jade
– newscore.jade
– layout.jade
app.ts
db.ts
express.d.ts
mongodb.ts
node.d.ts
package.json

Lo primero que haremos será crear el fichero de definición de paquetes para poder instalarlos. Este será nuestro package.json:

{
    "name": "application-name"
  , "version": "0.0.1"
  , "private": true
  , "dependencies": {
      "express": "2.5.8"
      , "ejs": ">= 0.5.0"
      , "jade": ">= 0.0.1"
      , "mongodb": ">= 1.0.0"
  }
}

Y los instalamos con la instrucción:

npm install

Con lo que veremos que se añaden los paquetes necesarios a nuestra carpeta node_modules.

A continuación vamos a editar el fichero principal de la aplicación, en nuestro caso será app.ts, que la extensión sea .ts indica que se trata de un fichero con código TypeScript. En este fichero es donde usaremos ExpressJS para establecer el enrutamiento que aceptará nuestra aplicación. Para una guía de uso de Express Framework os recomiendo esta de Javier Viola, en este artículo nos centraremos en la implementación con TypeScript.

Antes de nada, debemos añadir las referencias de lo que vamos a utilizar, esto en TypeScript se hace con la siguiente línea:

///<reference path='node.d.ts' />

Los ficheros con extensión *.d.ts indican que dicho fichero tendrá la definición de elementos (módulos, interfaces, clases, variables globales y funciones) que necesita TypeScript para importarlos a la hora de compilar. Pero estos ficheros no generan ningún fichero JavaScript, son simplemente definiciones en TypeScript de librerías JavaScript. Por tanto, igual que los ficheros .ts, no es necesario que se desplieguen en los servidores de producción.

Nota: la extensión .d.ts es una convención y puede que nos encontremos ficheros de definiciones sin ella, ya que no es obligatoria. Estos ficheros de definición son mantenidos por la comunidad de desarrolladores ya que comentaba antes, TypeScript es un proyecto Open Source.

Una vez referenciado el fichero de definiciones que nos permite trabajar con el paquete de Node, procedemos a importar los módulos que utilizaremos en nuestra aplicación:

import http = module("http")
import url = module("url")
import routes = module("./routes/index")
import db = module("./db")
import express = module("express")

Estos import serán traducidos a instrucciones del tipo var express = require(‘express’); siempre que sean necesarias, ya que, como comentábamos antes, TypeScript necesita definiciones para saber qué compilar, aunque a veces no tiene un reflejo en el JavaScript resultante.

Creamos una instancia del objeto express y procedemos a configurarlo. Podemos ver como con TypeScript las funciones anónimas pasan a ser () =>{…}, que son expresiones lambda, luego veremos cómo quedan tras compilar:

var app = express.createServer();

// Configuration
app.configure(() => {
  app.set('views', __dirname + '/views');
  app.set('view engine', 'jade');
  app.use(express.bodyParser());
  app.use(express.methodOverride());
  app.use(express.static(__dirname + '/public'));
});

app.configure('development', () => {
  app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});

app.configure('production', () => {
  app.use(express.errorHandler());
});

Ahora asignamos las rutas al que aceptará nuestra aplicación. Como dijimos anteriormente será algo muy sencillo y simplemente tendremos la opción de hacer llamadas GET, que devuelve la lista completa de puntuaciones, y un POST para añadir nuevos elementos. Empecemos sólo con el GET:

// Routes
app.get('/', routes.index);

app.listen(3000, function(){
    console.log("Demo Express server listening on port %d in %s mode", 3000, app.settings.env);
});

export var App = app;

Para comprobar que todo está correcto, compilamos el fichero app.ts y obtenemos su correspondiente fichero JavaScript:

tuto-2

Vamos a crear un fichero con el nombre index.ts, que se trataría de nuestro “Controlador” (recordemos que vamos a seguir el patrón MVC) dentro de nuestra carpeta /routes y añadimos el siguiente código:

// Importamos los módulos que vamos a utilizar
import express = module("express")
import db = module("../db")

// Y exponemos un método que devuelva los elementos de la tabla "highscores".
export function index(req: express.ExpressServerRequest, res: express.ExpressServerResponse){
    db.getScores(function(scores) {
        res.render('index', { title: 'Highscores', scores: scores })
    });
};

Como vemos, hacemos referencia al módulo “db” y llamamos a un método getScores. Esto lo hacemos así para separar el acceso a datos del sistema de rutas y de la generación de las vistas.

Autor de éste Artículo

Pablo Bouzada, desarrollador especializado en .NET y otras tecnologías Microsoft. Consultor en Pasiona Consulting y divulgador tecnológico en Techdencias. Colaborador de programandonet.com y otros grupos de usuarios de España.

Twitter: @pbousan

Slideshare: http://www.slideshare.net/pbousan

GitHub: https://github.com/pbousan?tab=repositories