node.js ou le triomphe de Javascript

Par Kadda SAHNINE

Publié le | 8 mars 2010 | Pas de commentaire

En des temps préhistoriques (1996), l’emblématique mais défunte société Netscape commercialisait LiveWire, une implémentation du langage Javascript intégrée au serveur web maison (Enterprise Server) dans le but d’unifier les langages de développement côtés client et serveur.
Le succès de la plateforme Java a eu raison de LiveWire et les quelques initiatives visant à promouvoir le langage Javascript comme un langage pivot du développement d’applications web a toujours suscité des sourires en coin ou des soupirs convenus…

Peut être est-ce toujours votre cas. Il est alors fort probable que vous n’ayez jamais entendu parlé du projet node.js dont nous pensons qu’il marquera l’agenda technologique de l’année 2010.
Cet article sera l’occasion d’oublier les préjugés et de porter un regard intéressé sur une initiative située à la périphérie des solutions établies.

Présentation

node.js est un framework Javascript serveur construit au dessus de V8, le très performant moteur Javascript open source soutenu par Google et utilisé notamment par le navigateur Chrome.
Peut être connaissez vous le serveur web Lighttpd, un compétiteur très performant du serveur web Apache. Contrairement à ce dernier où chaque requête est traitée par un processus dédié, Lighttpd n’utilise qu’un seul thread où le traitement des entrées sorties est non bloquants. Avec des I/O bloquantes (cas d’Apache), l’application cliente est bloquée tant que la communication est en cours et, dans certains cas d’utilisations comme le push de données, le serveur passe son temps à attendre la fin des opérations d’entrée/sortie.
Comme Lighttpd, node.js gère des entrées/sorties non bloquantes et supporte un modèle de programmation évènementiel ce qui en fait une excellente plateforme de développement d’applications orientées réseau (messagerie instantanée, systèmes de notification temps réel, etc.) performantes et scalables car pouvant gérer un nombre très important de requêtes simultanées.
En outre, grâce à son support des closures, l’usage du langage Javascript est très adapté à la programmation évènementielle.
Sans surprises, c’est donc dans le champ des applications web temps réel ou asynchrones que node.js excelle.

Installation

Le code est constitué de 8000 lignes de sources C/C++ et 2000 lignes de Javascript. Le mode opératoire d’installation à partir des sources du repository git est le suivant :

git clone git://github.com/ry/node.git
cd node; ./configure
make
sudo make install

Par défaut le binaire est installé sous /usr/local/bin. Faites un ./configure --prefix le cas échéant.

Prise en main

node.js est encore un projet très jeune et l’API évolue
substantiellement. Les exemples de code que nous fournirons sont
compatibles avec la version 0.1.31.

La programmation évènementielle est à la base de node.js. A titre d’illustration, le code source ci-après (tcpecho.js) implémente un serveur TCP écoutant sur le port 7000 et retournant en écho la saisie d’un utilisateur :

var tcp = require(”tcp”);
var server = tcp.createServer(function (socket) {
  socket.setEncoding(”utf8″);
  socket.addListener(”connect”, function () {
    socket.write(”Bienvenue\r\n”);
  });
  socket.addListener(”data”, function (data) {
    socket.write(”-> ” + data);
  });
  socket.addListener(”end”, function () {
    socket.write(”goodbye\r\n”);
    socket.close();
  });
});
server.listen(7000, “localhost”);

La commande node tcpecho.js active le service, lequel est accessible via un telnet localhost 7000.
Notez que le code est d’une simplicité remarquable car vous n’avez pas à vous préoccuper de la gestion concurrente des accès, de gérer des threads ou des ressources critiques.

Un peu plus élaboré, l’exemple suivant (webdate.js) implémente un service web retournant la date du jour :

var http = require(’http’);
http.createServer(function (req, res) {
  setTimeout(function () {
    res.writeHead(200, {”Content-Type”: “text/html”});
    res.write(”node.js demo”);
    var current_date = new Date();
    res.write(”Date actuelle : ” + current_date)
    res.close();
  }, 1);
}).listen(8080);

La commande node webdate.js active le service, lequel est accessible via l’URL http://localhost:8080.

Le code ci-dessus, entièrement écrit en Javascript, est assez trivial. Il consiste à :

• inclure la bibliothèque standard http
• créer un serveur web écoutant sur le port 8080 et auquel on attache une routine gérant les appels entrants (le closure en paramètre de la méthode createServer())

Au delà des exemples

Nous n’avons fait que gratter la surface du champ d’application. node.js est un framework de bas niveau à portée générique pouvant adresser un très grand nombre de problématiques. Le framework peut être étendu par l’adjonction de modules spécialisés (templating, gestion de la persistance, parseurs, etc.).
On assiste donc au développement d’un dynamique (mais peu structuré) écosystème de frameworks spécialisés construits au dessus de node.js.

Des frameworks web

Qui peut le plus, peut le moins. Il est possible de développer des applications web avec node.js bien que nous pensons qu’il ne s’agit pas là de son domaine de prédilection.
Simon Willison a initié le projet djangode implémentant un framework web de type MVC et dont la conception s’inspire de Django. A noter l’initiative de Benjamin Thomas, créateur de Bomber, un autre framework web aux ambitions similaires.

Des frameworks pour le web asynchrone

Nous avons eu l’occasion de publier une étude très détaillée des techniques du web temps-réel (ou asynchrone). Elle mériterait d’être complétée car node.js est particulièrement bien adapté pour ce champ d’applications car il est, si l’on peut dire, Comet enabled.
Les initiatives fusent. Guillermo Rauch a initié le projet node.websocket.js permettant la mise en oeuvre d’un serveur implémentant le protocole WebSocket, alternative sérieuse à Comet. Jacek Becela a développé une librairie équivalente mais assez minimaliste.
Enfin, André Gonçalves a eu l’idée d’assembler le tout en proposant une application web affichant en temps réel l’activité d’un compte sur Twitter.

Plus intéressant, le projet Faye est une implémentation du protocole de Bayeux construite sur node.js. Pour mémoire, le protocole de Bayeux définit un modèle de programmation de type publish/subscribe pour la construction d’application web temps-réel. Nous vous renvoyons à notre étude pour de plus amples détails.

Mais encore

Vous pouvez implémenter aisément votre propre système de messagerie temps réel, ou implémenter un jeu multi joueurs et temps-réel.
node.js a aussi la prétention de rogner sur le terrain des ESBs. On peut citer par exemple un agrégateur de logs en temps-réel ou un système de notification de transfert de fichiers.

Attention : il est possible que les projets sus-cités utilisent une version de node.js non compatible avec la version actuelle de l’API.

Pour aller plus loin

• Présentation vidéo de Ryan Dahl (JSConf 2009)
• Comet with node.js and V8
• Groupe de discussion du projet
• Liste officielle des modules node.js

Bien que ce billet d’introduction est d’une longueur honorable, nous n’avons fait que gratter la surface du sujet.
Hasardons cette prévision audacieuse : l’année 2010 verra vraisemblablement la consécration de ce projet et le développement d’un écosystème varié si l’API arrive à se stabiliser. Peut être contribuera il à légitimer l’utilisation de stacks Javascript complètes (jQuery/node.js/couchDB), là où les cas d’utilisations sont les plus adaptés.
Nous publierons prochainement d’autres articles relatifs à node.js, assurément un des projets à suivre en 2010.

select * from internet

Par Kadda SAHNINE

Publié le | 15 février 2010 | Pas de commentaire

Lancé initialement en Octobre 2008 puis réactualisé en Avril 2009 (YQL Execute), Yahoo Query Language a fait l’objet d’une utilisation originale par Chris Heilmann à l’occasion de la publication d’un billet proposant une solution au problème des requêtes cross-domain.
En effet, pour des raisons de sécurité, tous les navigateurs interdisent l’accès à des ressources n’appartenant pas au domaine depuis lequel un document a été chargé (sauf pour les balises img, script, link et iframe), ce que l’on désigne par les règles dites Same Domain Policy ou Same Origin Policy.

Le titre sibyllin de cet article est une occasion de (re)découvrir YQL, probablement un des projets les plus révélateurs d’une tendance fondamentale : l’émergence du Web des Données.

Retour sur YQL

Yahoo! Query Language est un langage apparenté à SQL permettant de construire des requêtes sur des données structurées ou non structurées, disséminées sur le Web.

L’idée force consiste à organiser les ressources du Web sous la forme de tables, la plus générique étant la table html.

Ainsi, la requête suivante permet d’extraire le cours de l’indice CAC 40 issu de Google Finance :

SELECT * FROM html WHERE
url=’http://www.google.com/finance?q=INDEXEURO%3APX1′
AND xpath=’//span[@id=\’ref_12156165_l\’]/text()’

YQL Console permet d’évaluer les requêtes avant leur intégration dans des programmes. Cette console est en outre un outil indispensable pour parcourir l’ensemble des tables exposées comme autant de perspectives d’organisation de données à priori déstructurées.

On découvrira entre autres qu’il est possible de requêter :

• des services en ligne exploités par Yahoo! (liste non exhaustive)
• Yahoo! Search : table search.web
• Yahoo! Météo : table weather.forecast
• Yahoo! News : table search.news
• Yahoo! Music : table music
• Flickr : table flickr
• des ressources structurées (liste non exhaustive)
• flux RSS : tables rss ou feed
• services REST : tables xml ou json

Nous verrons plus loin que le catalogue des tables est extensible et est ouvert à des tiers.

YQL par l’exemple

A titre d’exemple, voyons comment afficher l’état du trafic RATP et Transilien à l’aide de YQL et jQuery. Le résultat final est présenté dans la copie d’écran ci-dessous :

Pour ce faire, nous avons besoin :

• d’une source de données : l’état du trafic est accessible depuis un sous menu obscure du site InfoTrafic
• d’isoler les données à extraire : la zone utile est définie de manière assez triviale par la requête xpath suivante : //div[@class='central']/p
• d’utiliser la librairie Javascript jQuery pour lier la requête YQL et les boutons associés à un mode de transport

La requête YQL d’extraction de l’état du trafic du métro est la suivante :

SELECT * FROM html
WHERE url=’http://www.infotrafic.com/transport.php?region=IDF&link=trans.php?rub=METRO’
AND xpath=’//div[@class=\’central\’]/p’

Le code jQuery ci-dessous contextualise la requête en fonction du mode de transport et gère l’affichage du résultat :

$(function() {
  $(”button”).click( function() {
    var mode=$(this).attr(”alt”);
    $.ajax( {
      method: ‘GET’,
      url: ‘http://query.yahooapis.com/v1/public/yql?q=select%20%2A%20from%20html%20where%20url%3D%27http%3A%2F%2Fwww.infotrafic.com%2Ftransport.php%3Fregion%3DIDF%26link%3Dtrans.php%3Frub%3D’ + mode + ‘%27%20and%20xpath%3D%27%2F%2Fdiv%5B%40class%3D%5C%27central%5C%27%5D%2Fp%27%20&format=xml’,
      success: function( data, status) {
        $(”#trafic”).html( $(data).find(”p”) );
      }
    });
    mode = null;
    return false;
  });
});

La démo, librement utilisable, est déployée sur l’excellent service JS Bin depuis lequel vous pouvez consulter le code source.

Vers un Web des Données

L’ensemble des services proposés par Yahoo! (moteur de recherche, météo, finance, géolocalisation, etc.) est exposé sous la forme de tables.
L’idée de la communauté Open Data Tables consiste à généraliser ce modèle d’organisation des données vers des systèmes tiers producteurs d’information (plateformes sociales, journaux, associations, organisation publiques et privée, etc.).

De manière schématique, un descripteur YQL (format XML) permet de définir les règles de mapping entre une source de données REST et une table au format YQL. Les champs de la table utilisés dans les clauses WHERE correspondent aux paramètres de la requête.

Le portail datatables.org contient une quantité impressionnante de descripteurs.
Ainsi, le descripteur http://www.datatables.org/twitter/twitter.user.timeline.xml modélise la timeline d’un compte Twitter. Son utilisation est des plus triviale :

USE ‘http://www.datatables.org/twitter/twitter.user.timeline.xml’ as twitter;
SELECT * FROM twitter WHERE id=”ksahnine”

D’autres descripteurs sont en cours de développement et sont accessibles sur le repository github, comme le descripteur des statuts Google Buzz,  http://github.com/yql/yql-tables/raw/master/google/google.buzz.updates.xml utilisable comme suit :

USE “http://github.com/yql/yql-tables/raw/master/google/google.buzz.updates.xml” as google.buzz.updates;
SELECT * FROM google.buzz.updates WHERE user=”ksahnine”.

Ce paradigme d’organisation des données proposée par Yahoo! est problablement l’illustration la plus tangible de la transition - annoncée il y a 10 mois par Tim Berners Lee - d’un Web des Documents vers un Web des Données.

Pour aller plus loin, nous vous invitons à consulter la documentation officielle publiée par Yahoo! :

• YQL guide
• YQL documentation (sur Scribd)

L’inexorable migration du tiers présentation

Par Kadda SAHNINE

Publié le | 9 janvier 2010 | Pas de commentaire

Véritable canard boiteux de l’informatique, le langage Javascript a su s’imposer dans le paysage actuel du développement web.
Remis au goût du jour en 2004 grâce à la généralisation des techniques AJAX, il a acquis une véritable légitimité depuis la montée en puissance des librairies Javascript dans les années 2005 et 2006, parmi lesquelles on compte jQuery, MooTools, Prototype, Script.aculo.us ou encore Dojo.

Ces années ont à ce titre constitué un tournant important pour le développement d’applications web car l’adoption désormais massive de ces librairies a profondément changé l’ergonomie et l’expérience utilisateur jusqu’à l’architecture même des applications.

Le moment est propice car ce regain d’intérêt est également lié à la convergence d’autres tendances favorables :

• l’utilisation des formats de données interopérables : JSON, XML, YAML, voire GData
• la généralisation des architectures REST

Un rééquilibrage vers le navigateur

Tout d’abord cantonnées à des usages d’appoint (animations, effets graphiques de type Zebra), les librairies Javascript ont progressivement absorbé des responsabilités aujourd’hui encore dévolues au serveur comme les opérations de tri et de pagination de tableaux, la validation de formulaires ou l’implémentation de composants graphiques de haut niveau (calendrier, boîtes de dialogue, onglets, treeview, etc.).

Ce rééquilibrage à l’œuvre vers le navigateur atteint son apogée avec l’apparition de frameworks MVC Javascript consacrant la migration complète du tiers présentation.

Pourquoi un tel engouement pour ce type d’architecture aujourd’hui ? Probablement parce qu’il est totalement adapté aux architectures REST et est le plus compatible avec un backend organisé en nuage (cloud computing).

Nous aurons l’occasion de revenir sur ce sujet à l’occasion de la présentation de deux frameworks MVC purement Javascript et emblématiques de cette approche :

• SproutCore, un projet déjà solidement établi soutenu par Apple
• corMVC, une initiative récente s’appuyant sur jQuery

— keep looking »