Refactorisation en coffeescript d'une application Express

Je teste  des exemples en javascript que je reprends le plus souvent en Coffeescript.
L'erreur fréquente est de tenter de reprendre tel quel le code javascript. Aussi j'ai réalisé une vidéo explicative sur les modalités de re-factorisation d'un code javascript en coffeescript.
Je suis parti d'une application javascript générée pour le framework  Express.

Pour des raisons de taille j'ai fractionné le vidéo en deux parties. Elles disponibles  sur youtube respectivement ici pour la partie I et ici pour la partie II. 

Les slides de la présentation et les videos intégrées sont disponibles également sur le site slideshare.

  

Il est possible de travailler directement en coffeescript sur des applications d'Express avec les produits : Zappa et Express-Coffee

Le résultat de la re-factorisation est le suivant:

	express = require 'express'
	routes = require './routes'
	http = require 'http'
	app = express()
	middleware = () ->
	app.set 'port', process.env.PORT || 3000
	app.set 'views', __dirname + '/views'
	app.set 'view engine', 'ejs'
	app.use express.favicon()
	app.use express.logger('dev')
	app.use express.bodyParser()
	app.use express.methodOverride()
	app.use app.router
	app.use express.static(__dirname + '/public')
	error = () ->
	app.use express.errorHandler()
	app.configure middleware
	app.configure 'development',error
	app.get '/', routes.index
	port = app.get 'port'
	mesdg = () ->
	console.log "Express server listening on port " + port
	monserveur = http.createServer app
	monserveur.listen port , mesdg

view raw appc.coffee hosted with ❤ by GitHub

Dans le vidéos, j'utilise l'IDE sublime Text qui affiche directement la traduction en javascript du code coffeescript.

• J'élimine les ';' et les mots clés 'var'.
• Les fonctions  sont appelées sans les parenthèses autour des paramètres  sauf pour les appels de fonction sans paramètre.
• Les fonctions anonymes sont sorties des blocs pour devenir des fonctions nommées.
• Les appels de fonction chaînés par un '.' sont individualisés.

Des uploads formidables avec le module formidable pour node.js

Le transfert de fichier entre un client et un serveur reposait habituellement sur des protocoles de transferts dédiés: exemple FTP , SFTP (via ssh) ou TFTP (trivial FTP) . Mais l'usage du navigateur comme client léger universel a modifié les usages.
Il est fréquent maintenant de recourir au protocole HTML et HTTP pour 'uploader' ou' downloader'  des fichiers (video , photo etc.)

source : site du zero

Nous allons nous intéresser à l'utilisation du module Formidable pour node.js dans le cadre de l'upload (sens client vers serveur)

L'usage d'un serveur node.js est particulièrement adapté à ce type de service. Les connexions sont longues (le temps de transfert), par morceaux (trunk) et avec des temps de latences importants en raison des débits des réseaux.
Aussi le cas d'usage de l'upload est en plein dans le cœur de cible de node.js

Le module formidable

Son installation se fait par le gestionnaire de paquetage npm.
La commande d'installation est la suivante:
npm install formidable@latest
Avec comme résultat:

npm http GET https://registry.npmjs.org/formidable
npm http 200 https://registry.npmjs.org/formidable
formidable@1.0.11 node_modules/formidable

Le module est livré avec des exemples pour commencer des essais.

Le dialogue client/serveur est fait par le biais d'un formulaire html qui doit avoir les propriétés suivantes:

enctype="multipart/form-data" method="post

Et contenir une balise INPUT de type "file" name="upload" multiple="multiple"

(le code HTML est dans le répertoire 'example'  du module)

La requête envoyée au serveur va contenir des tronçons délimités par des 'boundary'. 
Un tronçon va contenir les données du fichier à télécharger  (l'image, le son ) , un autre contiendra les autres paramètres du formulaire.

Cette dualité se retrouve au niveau des évènements  gérés  par le module (on 'file' , on 'field')

form.parse(req, function(err, fields, files)

Un exemple complet  ici en coffeescript:

	upf = require 'formidable'
	http = require 'http'
	util = require 'util'
	monserveur = http.createServer (req, res) ->
	if (req.url == '/upload' && req.method.toLowerCase() == 'post')
	# parse a file upload
	console.log "ok j arrive"
	form = new upf.IncomingForm()
	form.uploadDir = "./tmp"
	form.parse(req, (err, fields, files) ->
	console.log fields
	console.log files
	res.writeHead(200, {'content-type': 'text/plain'})
	res.write('received upload:\n\n')
	res.end(util.inspect({fields: fields, files: files}))
	)
	else
	console.log ('reception upload')
	res.writeHead(200, {'content-type': 'text/html'})
	res.end(
	'<form action="/upload" enctype="multipart/form-data" method="post">'+
	'<input type="text" name="title"><br>'+
	'<input type="file" name="upload" multiple="multiple"><br>'+
	'<input type="submit" value="Upload">'+
	'</form>' )
	monserveur.listen 8080

view raw upload.coffee hosted with ❤ by GitHub

Il est souhaitable d'indiquer un répertoire  (uploadDir) de réception qui sera par défaut /tmp.
Le fichier sera nommé à l'aide d'une chaîne aléatoire. Le nom d'origine du fichier (celui du poste client) est indiqué qu'a titre indicatif.
Ce module est utilisé en production par des sites de téléchargement professionnels. Il est donc hautement recommandé de l'utiliser à la place de solution interne.

Nous verrons dans un autre post comment utiliser le module 'formidable' avec le framework 'express'

La librairie D3.js pour la visualisation des données: nouvelle réference

Jusqu’à présent Jasper-report régnait en force sur les solutions de visualisation de données dans le monde du décisionnel opensource.

 Une restitution Jasper-report  est construite sur le serveur puis elle est envoyée au client.
Or, la visualisation est avant tout une affaire de client. C'est bien l'utilisateur via son navigateur qui  doit pouvoir   manipuler et enrichir les  données. Aussi logiquement, le javascript prend toute son importance comme acteur majeur dans la chaîne  des restitutions.

Plusieurs bibliothèques sont présentes sur ce domaine. Mais dans lot une librairie se dégage : d3.js

Comme jquery dans le domaine de la navigation  d3.js prend le chemin de devenir le composant de référence.

(illustration tirée d'une présentation de d3.js lien ici)


Il est à la base du projet ndvd3.js .

Ou encore rickshaw

D'autres liens ici.

La carte Hadoop pour ne pas se perdre dans le bigdata

J'ai assisté à une réunion du HUG_France : Hadoop user group.  Un des conférenciers était Ted Dunning de la société MapR.

Pour clarifier les chose , j'ai fait cette carte d'Hadoop représentant les principaux composants.

L'état de l'art à ce jour:
Il est possible de stocker des gros volume de données structures ou non sur un système de fichier distribué.  Il est possible de réaliser des opérations BATCH distribuées de sélection et de réduction sur ces données.
L'enjeu actuel est la recherche et le la restitution en temps réel dans ces gros volumes (Big Data).
Un contournement peut etre fait par des exports de données d'Hadoop vers des modes de stockage et de restitutions plus rapides: exemple  mongodb.

Quand la démocratie s'inspire du logiciel libre

Légifrance a ouvert un espace de partage sur la forge github :https://github.com/legifrance

Cette diffusion trouve une suite dans l'article 'faire la loi ensemble' d  Hubert Guillaud

Pour résumer:  des communautés se réunissent autours des logiciels libres, elles orientent les développements: elles travaillent ensembles pour le meilleur:    peut on appliquer ce dispositif  à un système politique ?

Javascript: l'invité d'honneur de la conférence javaone 2012

La grande messe java organisée par oracle  s'est déroulée au mois d'octobre 2012  à San Francisco. Cette année l'invité d'honneur de la javaone était le javascript...

Nashorn.

Le rhinocéros est mort !  Oracle ne supportera plus le projet rhino qui permettait d'exécuter du javascript sur une JVM java.

Vive le rhinocéros teuton: Oracle a porté sur les fonts baptismaux le projet Nashorn (rhinocéros en allemand) . Ce projet reprend les grande lignes de Rhino. (sauf peut être les termes de la licence)

C'était aussi le nom d'un véhicule anti-char allemand de la 2eme gerre mondiale.

Quelle est la cible ? .
 Oracle a fait la part belle à HTML5  et javascript pendant sa kermesse.

Les conférences consacrées à Nashorn ont mis en vedette une librairie : node.jar (pas en opensource à ce jour)
Cette librairie permet de faire tourner un programme javascript destiné à Node.js sur une JVM.

JSON

Le JSON aura à présent une place d'honneur dans le langage Java.
Rappel : JSON = (JavaScript Object Notation)



D'autres éléments de la galaxie Java ont été évoqués :

• Le langage SCALA.
• La machine virtuelle JRuby pour le langage Ruby.

Concernant l'orientation Elastic Cloud de java, il faudra attendre la version 1.8 de l'an prochain.

Moi, j'étais déjà passé à Java 2 en 1998  (non pardon en java 1.2  ;-)) )
Cette ouvrage ne parlait du web qu'au travers des applets... , je dois bien être le plus vieux programmeur Java du quartier.

Ne parlons plus de javascript mais de Ecmascript c'est plus sur !


Les liens ici 
http://www.developpez.com/actu/48326/JavaOne-2012-Oracle-presente-la-specification-JSR-353-l-API-Java-pour-la-manipulation-avec-souplesse-du-format-JSON/

http://pragprog.com/magazines/2012-11/the-javaone-snooze

http://www.developpez.com/actu/48218/JavaOne-2012-Oracle-sort-la-Preview-de-NetBeans-7-3-et-devoile-Easel-une-extension-pour-la-creation-des-clients-RESTful-JavaScript/

Utilisation de la librairie async.js pour Node.js

Dans un environnement synchrone classique, les fonctions s’enchaînent les une a la suite des autres de manière linéaire.

Avec Node.js doté d'un système d'entrée-sortie  non bloquant et asynchrone, les choses ne se déroulent pas toujours dans l'ordre souhaité.

Soit par exemple 3 fichiers: un petit , un moyen et un gros fichier.

Le programme ci-dessous en coffeescript va lire les 3 fichiers:

	fs = require 'fs'
	# lecture 1er fichier (le plus gros)
	fs.readFile 'big_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le gros fichier"
	#lecture 2eme fichier (le moyen)
	fs.readFile 'middle_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le moyen fichier"
	#lecture 3eme fichier(le plus petit)
	fs.readFile 'little_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le petit fichier"
	console.log "traitement termine"

view raw async1.coffee hosted with ❤ by GitHub

Le résultat d'exécution sera:

>coffee async1.coffee 
traitement termine
 Je termine de lire le petit fichier
 Je termine de lire le moyen fichier
 Je termine de lire le gros fichier

Deux remarques:

Le display de la dernière ligne s'affiche en premier . 

Les fonctions se terminent dans un ordre différent de leur appel: celle relative au fichier le plus petit , appelée en dernier se termine la première.

Tout cela est normal dans une logique asynchrone: Toutes ces appels de fonctions sont réalisés dans le même cycle d'exécution du moteur Node.js. Node.js n'attend pas la fin de l’exécution de la fonction pour passer à la suivante.

Pour enchaîner l’exécution des fonctions dans un ordre précis il faudrait re-ecrire le programme comme ceci:

	fs = require 'fs'
	# lecture 1er fichier (le plus gros)
	bigf = -> fs.readFile 'big_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le gros fichier"
	midf()
	midf = -> fs.readFile 'middle_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le moyen fichier"
	litf()
	#lecture 3eme fichier(le plus petit)
	litf = ->fs.readFile 'little_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le petit fichier"
	bigf()
	console.log "traitement termine"

view raw async2.coffee hosted with ❤ by GitHub

Avec cette fois le résultat suivant:

> coffee async2.coffee
traitement termine
 Je termine de lire le gros fichier
 Je termine de lire le moyen fichier
 Je termine de lire le petit fichier

Chaque fonction appelle la fonction suivant dans sa dernière instruction. On se retrouve alors à devoir gérer des callbacks imbriqués dans des fonctions. Le programme perd en lisibilité.

Il existe une librairie très populaire dans la sphère de Node.js : async.js. qui prend en charge ce type de problème.
Ce module disponible par la commande  npm install async. permet de gérer plus facilement l'ordre d’exécution des fonctions.

	fs = require 'fs'
	async = require 'async'
	# lecture 1er fichier (le plus gros)
	bigf = (callback)-> fs.readFile 'big_file', (err,data) ->
	console.log callback.toString()
	if err
	throw err
	console.log " Je termine de lire le gros fichier"
	callback()
	midf = (callback)-> fs.readFile 'middle_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le moyen fichier"
	callback()
	#lecture 3eme fichier(le plus petit)
	litf = (callback) ->fs.readFile 'little_file', (err,data) ->
	if err
	throw err
	console.log " Je termine de lire le petit fichier"
	callback()
	#traitment en série
	order = async.series [bigf,litf,midf]
	#traitment en parallele
	orderp = async.parallel [bigf,litf,midf]
	console.log "traitement termine"

view raw async3.coffee hosted with ❤ by GitHub

Dans cet exemple, on utilise deux formes d'appel : le mode en série et parallèle.
Dans le  mode en série (serial),  async.js va attendre la fin de chaque fonction pour lancer la suivante.

remarque1 : async.js appelle vos fonctions en ajoutant une fonction de retour en paramètre  ce parametre ne sert qu'a un usage interne à async.js
(midf = (callback)-> fs.readFile 'middle_file', (err,data) => ...)

remarque2: la méthode toString appliquée à une fonction permet de lister le source de la fonction
 (console.log callback.toString() ...)
   

Think asynchrone ...

Qu'est ce qu'un websocket

Les websockets sont un nouveau mode d'échange  d'information entre un client (navigateur) et un serveur, défini par la RFC 6455.

Source http://fernetjs.com/wp-content/uploads/2012/11/cables21.jpg

Le dialogue ente le client et le serveur commence par un échange HTTP ou HTTPS puis se continu en mode WS ou WSS (Web Socket et Web Socket Secure).

source:http://warmcat.com/websocket-lifecycle.png

Ce mode d'échange est Bidirectionnel : Le serveur peut pousser des informations au client (ce que ne permet pas directement le HTTP) . C'est le protocole d'avenir des applications web ou non web.

http://websocket-sample.googlecode.com/svn/trunk/images/ws_vs_http.png

Pour tester les websockets: avec Node.js , rien de bien compliqué:

npm install socket.io  

D'autant que les websockets sont adaptées à un fonctionnement de gestion d’évènement asynchrone non bloquant (Comme Node.js) 

Pour Ruby et Rails il existe un gem fournissant un serveur de websocket : em-websocket

En résumé: plus de souplesse , plus rapide moins verbeux, les  websockets sont les invités privilégiés  des smatphones ou des tablettes pour des applications interactives.

Comment enregistrer son terminal avec la commande script

Pour réaliser des screencasts , j'utilise Kazam  , mais il y plus simple: la commande script

La page de manuel de la commande script

La syntaxe de lancement est la suivante: 

script -t session1 2>session1.time

Et pour rejouer la session :
scriptreplay session1.time session1


Ce dispositif est plus léger qu'une vidéo et consomme moins de ressource.


Marcin Kulik a eu une idée géniale : proposer un système de partage pour ces enregistrements en mode console: c'est l'objet du site ascii.io

Pour simplifier cette tache , le site propose de telecharger une nouvelle  commande asciiio
(installation de la commande :curl -sL get.ascii.io | bash)

Cette commande se charge de tout: enregistrement et publication sur le site de partage.

(mon essai en bas à droite)
Pour réaliser son site l'auteur a utilisé du python, du bash , du ruby et nodes.
Mes screencasts sont ici sur slideshare.

good hacking

Nouvelle version 9.2 de Postgresql: Json pour tous

La nouvelle  version 9.2 de Postgresql supporte nativement le format JSON.

Le lien de cette page est ici.

Postgresql stocke des données au format JSON mais  peut aussi convertir à la volée des données dans ce format.
Encore une contribution de plus pour Javascript.

Les moteurs de node.js

Les moteurs de Node : Un V8 et.. un réacteur.

Article écrit dans le cadre de la série:  Node pour les 'pas tout à fait' nuls.

Le moteur V8.

Node n'a pas été écrit à partir de rien. Au contraire c'est un assemblage léger autour du moteur d'exécution javascript le plus répandu au monde : le moteur javascript 'V8' de google chrome.

Vous avez sur le site de liz Stinson des très bons articles sur l'architecture des navigateurs et de V8.

Ce moteur est utilisé chaque fois que votre navigateur Chrome a besoin d’exécuter du javascript.

La relation entre Node.js  et Chrome est un des facteurs du dynamisme du projet : les utilisateurs de Node poussent toujours plus loin l'usage de V8, ce qui profite directement au navigateur Chrome et réciproquement  toutes les améliorations du V8 profitent à la communauté Node.js.

Le réacteur. 

Le V8 fournit la coquille de  la machine virtuelle mais pas le mécanisme utilisé par Node.

Node est basé sur un modèle de traitement appelé : Event Model. La traduction n'est trop parlante: modèle évènementiel. 

Ce dispositif est avant tout un modèle de conception (design pattern), le reactor pattern.

L'idée de base est la suivante: node va lire la suite des instructions contenue dans votre programme javascript. Il va insérer  dans une boucle des agents chargés de guetter des évènements.Quand un évènement survient , l'agent chargé de le surveiller va déclencher QUAND SON TOUR viendra, une série d'action en rapport avec l’évènement à traiter (la fonction de rappel ou callback). 

Aussi, plus le nombre d’évènement à surveiller augmente, plus le nombre d'agent de surveillance va augmenter et plus le parcours de la boucle sera long. 

Les Entrées-Sorties non-bloquantes. 

Un réacteur fonctionnera parfaitement que s'il arrive à faire le tour de ses agents dans un temps raisonnable et qu'aucun agent ne monopolise son attention. Les fonctions d’entrées-sorties (disque ou réseau)  sont les opérations qui génèrent le plus de temps de latence.

Comparaison des vitesses RAM et E/S

(lien vers la conférence de jerry Cheung ici) 

 Aussi , il ne faut pas que le système attende l'achèvement  d'une telle fonction pour continuer sa ronde. Le principe des E/S non bloquantes  est simple: je lance une opération sur le réseau ou le disque  et je charge un observateur de m'avertir de la conclusion de l'opération, pendant ce temps, je passe à l'opération suivante. 

Ainsi la ligne d'appel d'une opération non bloquante sera de la forme:

 res.on('data', function(d) {
    process.stdout.write(d);
  });

Le système va charger un agent de surveiller l'arrivée de l’évènement 'data' et dans ce cas, de  lancer la procédure de rappel (callback ) associée.

Pour des fonctions plus simples, l’évènement peut implicitement correspondre à la fin de l'opération:

fs.readFile('/etc/passwd', function (err, data) {
  ... } ) 

Cette ligne déclenche la demande de lecture du fichier, puis une fois l'acquisition réalisée, appellera la fonction de rappel.

Ce mode de fonctionnement est la mise en oeuvre d'une forme de programmation particulière: la programmation asynchrone.(A détailler dans un article).

La communauté.

Node est issu du cerveau génial de Ryan Dahl qui est un ovni dans la planète du Net.

Ryan Dahl , le créateur de Node.js a complété le moteur V8 de Chrome pour lui permettre de réaliser des opérations qui ne sont pas prévues en javascript pour un navigateur. On peut citer par exemple l'accès au système de fichier : cette fonction est interdite pour un navigateur.

L'aventure a commencé en 2008 et connait depuis une progression vertigineuse.

• En 2009 : Node c'est 8000 lignes de  C/C++ et  2000 lignes de Javascript, 14 contributeurs. 
• En 2010 : Node c'est 11000 lignes of C/C++ et  6000 lignes de JavaScript,  63 contributeurs.

En 2012:  17 881  librairies javascript.

Cette communauté est fédérée autour d'un référentiel des librairies pour Node : npm (Node Packaged Modules)

Licences.

Enfin pour terminer, Node.js est sous licence MIT, le moteur V8 sous licence BSD. Ces licences vous garantissent le caractère 'libre' de Node.js sans aucune restriction.

A venir: qui utilise Node et pour quoi faire

Node.js pour les pas-tout-a-fait nuls

Cet article est destiné à faire le point sur Node.js avec un certain recul vis à vis des réactions positives ou négatives engendrées par ce phénomène.

généré à partir du site www.txt2pic.com

Node.js : c'est quoi ?

Node est une machine virtuelle capable d'exécuter des programmes javascript.

Node.js désigne l 'environnement (la galaxie) de Node (sans l'extension .js). Node est un programme (exécutable) écrit en C++ et compilé. Node n'est pas en javascript. Node est un programme qui va recevoir en entrée des fichiers sources de javascript, il va interpréter (traduire) en langage machine les instructions javascript et va les exécuter.

Le résultat de la commande file sur le fichier node

Node est donc un interpréteur de javascript. Il joue le même rôle que la JVM pour les projets java (Machine Virtuelle Java) mais pour le javascript !

Pourquoi le terme de machine virtuelle ?

Tout d'abord définissons le notion de portabilité

La portabilité d'un programme qualifie le niveau d'indépendance d'un programme vis à vis de la machine physique (système) qui l'accueille. Ainsi un programme dit 'portable' fonctionnera sur des systèmes différents, en l'état, sans changement de code majeur.

Pour assurer la portabilité d'un programme (javascript, java ou autre ) il est possible d'avoir deux approches :

La compilation adaptée.

La première approche consiste à recompiler les sources du programme en fonction des systèmes cibles : c'est le dispositif adopté pour les programmes en C ou C++. La contrainte forte est de pouvoir disposer des codes sources du programme et d'un compilateur. Cette solution n'est pas satisfaisante pour les langages interprétés.

L'utilisation d'un composant intermédiaire : la machine virtuelle.

La deuxième méthode consiste utiliser un composant qui va servir de médiateur entre le code (les instructions du programmes) et le système d'accueil : c'est le rôle de l’interpréteur appelé dans ce cas 'machine virtuelle'. Ainsi , il y aura une machine virtuelle adaptée à chaque environnement. Ces machines virtuelles prennent en charge l’interprétation des instructions d'un programme et leurs traductions adaptées au système de la machine physique hôte. Ces machines virtuelles masquent les disparités des environnements d'accueil. Elles prennent à leur charge la gestion des écarts de comportement, de matériel , d'appel de fonction système etc..

Remarque : Une machine virtuelle est couramment 'fabriquée' à partir de la méthode 1 (compilation adaptée) d'un projet 'modèle'.

Ainsi le programme Node va lire des fichiers qui contiennent des instructions 'javascript' et exécutera chaque instruction javascript en les traduisant par des instructions machines et des appels de fonction.

Il existe des machines virtuelles Node pour les systèmes les plus usités : Microsoft, Ubuntu , MacOS etc.

La liste de architectures supportées par Node

Un programme javascript s'exécutera et se comportera de la même façon sur tous ces environnements: le javascript est donc portable.

Le javascript est le seul langage de programmation normalisé (standard ECMA-262)  à pourvoir s’exécuter nativement dans un navigateur. Avec Node.js , il s’exécute à présent sur le serveur ou d'une manière générale en dehors du navigateur.

La suite à venir:   mettre un  V8 dans ses programmes, la licence Node.js etc..


Question bonus: Pourquoi les programmes java passent par une phase de pré-compilation (bytecode) ?

qsview: accéder instantanément à google street view

Sur ce site : http://www.qsview.com/ , il est possible d'afficher directement une image à partir de google street  view

Vous disposez des contrôles suivants:

Avec une possibilité d'exporter les images sans les boutons de contrôle.

Un système d'exploitation en javascript

Sur le site https://blog.netbsd.org/tnf/entry/kernel_drivers_compiled_to_javascript l'auteur explique comment il utilise javascript pour emuler un microkernel NetBSD.
En clair: comment disposer dans son navigateur EN LOCAL d'un véritable système d'exploitation.

La démo est ici:http://ftp.netbsd.org/pub/NetBSD/misc/pooka/rump.js/

L'écran se présente comme ceci:

La commande help donne le résultat suivant:

 Ici , nous sommes en présence non pas d'un webos (Système d'exploitation DISTANT sur le web) mais bien d'un OS_in_web : un OS (operatic system) dans le navigateur.

Pour quels usages ? : Un bureau hybride : je récupère mon bureau distant ,(webos) je me déconnecte  et je peux continuer  à travailler sans réseau , à la prochaine connexion je synchronise le tout.

Le contenu de la circulaire du Premier Ministre sur l'usage du logiciel libre dans l'administration

Dans une circulaire du 19/09/12 le Premier Ministre donne des orientations pour l'usage des logiciels libres dans l'administration.
Cette circulaire est accompagnée par une note de 18 pages de la DISIC :Direction interministérielle des systèmes d'information et de communication.

Cette  note reprend les origines du logiciel libre avec ses 4 libertés  fondamentales :
- La liberté d'utiliser un logiciel
- La liberté d'étudier le fonctionnement d'un logiciel
- La liberté de copier un logiciel
- La liberté  de modifier un logiciel

Avec comme conséquences:
- Un auto-entretient des logiciels
- Une évolution dictée par le besoin de l'utilisateur
- Une communauté qui conserve le contrôle du logiciel
- Une émulation des acteurs

La licence la plus connue est la GPL.
Un logiciel libre n'est pas forcement gratuit: le coût de licence peut être remplacé avantageusement par un coût de formation ou d'adaptation.

Le choix du logiciel libre est un choix raisonné pour des motifs de coûts et de la meilleure maîtrise du SI par les équipes.

Toutefois , il faut être vigilant à un bon usage du logiciel libre en tenant compte des critères suivants:
- La taille de la communauté
- Le modèle économique adossé: une vraie communauté ou un éditeur

L'administration doit faire chercher dans la limite du possible à reverser du code dans les communautés.

Le document liste les cadres favorables à l'utilisation du logiciel libre dont ces deux points importants:
- Dans le cadre de la virtualisation (en raison du mode de licence à l'usage CPU)
- Dans le cadre du développement Agile (opportuniste) .
.

Comment favoriser l'usage du logiciel libre dans l'administration ?.

La note  revient sur la mise en commun des efforts et afin d'éviter l'éparpillement, sur la nécessité d'un cadre de convergence des projets et des versions (souches).
Les mesures prônées sont par exemple:
- Création et maintient d'un catalogue des projets
- Animation d'un réseaux d'expert sur les thèmes communs  comme :

• La Bureautique (MIMO)
• Le socle système  (MIMOS) 
• La gestion de parc  (MIMOG) 
• Et les bases de données (MIMDB) 

Vive le web 0.2

Lors d'un screencast, j'ai utilisé le terme web 0.2 au lieu de web 2.0.
Sommes nous vraiment entré dans une version 2 du web ?

Pour ma part j'ai de plus en plus le sentiment que l'on est encore dans la préhistoire du web.

La révolution de l’hébergement des infrastructures et des plateformes  dans un Elastic Cloud et l'avènement de langages DSL vont nous propulser à la vitesse du son dans une nouvelle forme du web

Un web où le développeur sera au centre de l'univers.

J'exposais il y a maintenant 3 ans dans cet article :convergences des supports web 2.0
les évolutions d'un wiki.  C'était en avance de phase la description des systèmes de curation ou de yahoo Pipes.

Il y a encore du chemin à faire avant de disposer d'un système viral de publication. A partir d'une console de publication, le message serait diffusé sur d'autres medias qui eux mêmes se comporteraient comme une caisse de résonance.   

Déport de console d'un serveur graphique

Sur Linux l'affichage graphique est une application comme une autre. Son architecture est de type client serveur, on appelle ça le serveur X . Dans un usage normal le client et le serveur sont une seule et même machine.
Il est possible de déporter l'affichage d'un programme vers le serveur X d'une autre machine.

Dans ce cas les échanges entre le serveur et le client circulent en clair sur le réseau y compris le flux clavier.

Il est préférable  de profiter  d'une connexion SSH pour déporter l'affichage en faisant passer le flux graphique par le tunnel crypté de la connexion  SSH . 

Pour cela il suffit d'ajouter l'option '-X'  à 'instruction de connexion ssh.

Exemple ssh -X 192.168.1.12 . Puis plus tard lancer un programme X (xclock , xeyes, .. firefox ). Le programme va s’exécuter sur la machine distante mais l'affichage se fera sur  votre machine locale.
Cette technique peut servir à contourner des restrictions des pare-feux et des proxy  en le combinant avec d'autres outils: voir article ici.
 

Synchronisation delicious et twitter

J'utilise depuis longtemps le site de signet en ligne delicious. Ce site permet de stocker et de partager  des liens et des mots clés associés.

Delicious propose nativement  un service de synchronisation  de lien depuis vos tweets .
Pour ma part c'est l'opération inverse qui m’intéresse: quand j'ajoute un site sur delicious, je souhaite propager cette information via mon compte twitter.

Pour cela, j'ai ajouté un nouveau flux à twitterfeed. Ce site permet de récupérer des flux RSS d'origine diverse et de propager les informations vers d'autres réseaux sociaux.

Je m'en sert déjà pour alimenter Facebook et twitter depuis mon blog.

Le nouveau service va scruter le flux RSS de delicious et à chaque nouvelle entrée donnera lieu à la génération d'un tweet à destination de twitter.

Mon tableau de bord donne le détail des deux flux (Blog et delicious)

La première étape de la création du dispositif de synchronisation passe par la déclaration de la source des informations , ici mon flux RSS de delicious (sous la forme v2/rss/nom_utilisateur) .

Il est possible de mettre en forme les tweets :  ici j'ajoute la mention 'saved on delicious' avant les url de mes tweets.

La suite du processus consiste à préciser le réseau social cible : dans mon cas twitter.

Ainsi toutes les 30 minutes, mon flux RSS de delicious est vérifié, tout ajout de lien donnera lieu à l'émission d'un tweet correspondant.

Découvrir la virtualisation avec virtualbox

J'ai mis en ligne une nouvelle vidéo (screencast) sur le thème de la virtualisation.
Les supports sont regroupés sur le site slideshare.

Virtualisation avec virtualbox from eric german

L’accès direct à la video sur youtube est ici.

Partage de fichier.

Le point délicat de la virtualisation est le partage des fichiers.

Sur le machine hote , il ne faut pas oublier d'ajouter votre user au groupe virtualbox grace à la commande:

sudo usermod -G vboxusers  -a my_user
Sur la machine virtuelle seven le partage est disponible automatiquement.
Sur la machine virtuelle Linux , il convient de monter le répertoire partagé par la commande mount.


sudo mount -t vboxsf  virt /mnt/partage

Partie Réseau.

La partie réseau  peut demander quelques ajustements à la main dans le fichier interfaces des machines virtuelles ubuntu. 

Prenez garde à ne pas exposer vos machines virtuelles sur le réseau, elles peuvent être des vecteurs de transmission de malware au même titre qu'une machine réelle. 

En conclusion. 

C'est très amusant de jouer avec les machines virtuelles. Il faut avant tout de la ressource disque et memoire.  Aussi le dispositif  lxc des conteneurs est une solution plus adaptée pour des machines moins puissantes. Ce n'est rien de plus qu'un super chroot. 

Pour rappel, vous trouverez plus d'une dizaine de screencast en francais dans mon espace de publication youtube. 

Les #JO2012 et #twitter

Le grand gagnant des JO de Londres 2012 est ... twitter !
J'ai pris un grand plaisir à suivre les JO sur ma télé avec des belles images. Mais  j'ai coupé plusieurs fois le son pour éviter les inepties des commentateurs.  A plusieurs reprises , j'ai pris  connaissance d'information par twitter bien avant les commentateurs du plateau (#ftvjo). Ils sont sur place, avec toutes les accréditations qu'il faut et c'est moi spectateur lambda loin de Londres qui possède les informations avant eux. Ça provoque une certaine gêne. Le dispositif classique repose sur un commentateur sportif et un consultant. A l'avenir le commentateur sportif se contentera de lire les messages de twitter et de poser les questions au consultant.  Le consultant est le seul qui apporte une plus-value à une image qui peut le plus souvent se passer de commentaire. Il est destiné à devenir le pivot central de ce type d’évènement.  Twitter petit à petit grignote du terrain, c'est un catalyseur qui va accélérer  les évolutions et ringardiser encore plus vite la génération minitel.

France télévision a bien essayé d'intégrer twitter dans son dispositif en créant et en animant des hashtag (mot clé  dont #ftvjo) . Mais un tel système est à double tranchant et a été sans pitié pour les commentateurs de FTV. De la même manière qu'il existe des stratégies de référencement sur le Net  (SEO) pour les entreprises, il y a aussi des techniques à mettre en place pour gérer ses hashtags et pour en garder la maîtrise (voir les batailles de hashtag lors de l’élection présidentielle 2012) .

Il y en encore des progrès à faire et le chemin est long.