samedi 31 mars 2012

google maps en mode pixel

Perdu au fin fond de la campagne, le débit de la connexion ADSL est faible.
Heureusement google maps sait s'adapter:



Je plaisante, le lien ici vous permet de d'obtenir un google map pixelisé, un mode minitel ?


Sinon il suffit d'aller sous google maps et  de cliquer sur le bouton magique pour basculer dans l'univers du pixel.

mardi 27 mars 2012

Publier ses modules sur #npm pour #node.js

Réaliser ses propres modules pour node.js et les distribuer par le npm n'est pas très compliqué.

Ce post est destiné à exposer la manière de faire un module, le tester et afin le distribuer.

npm

npm est le node packager manager. C'est l'équivalant du cpan et de la commande cpan pour Perl ou encore du système de 'gems' gemmes pour Ruby.
npm est à la fois un dépot et une commande pour gérer ses modules.
lien sur npm


Préparation d'un  module pour npm.


Un module est tout d'abord une archive compressée contenant un fichier de metadonnée :le package.json et les fichiers de votre module.

La première opération à faire est de créer un répertoire de travail pour votre module:
ex : mon_mondule/
Puis en fonction des besoins, des sous-réperoires seront  préparés:


  •  tests/ : car vous êtes un développeur consciencieux
  •  lib/   : si votre projet prend de l'ampleur
  •  examples/ ou exemples/ : car vous êtes vraiment un développeur consciencieux
  •  bin/: si vous livrez des exécutables
Enfin un répertoire docs pour votre documentation volumineuse
 npm n'est pas directif dans les règles de nommage des répertoires.

Pour mon module cela donne :
(copie écran)


Dans votre répertoire du module lancer la commande : npm init
Cette commande vous posera une série de question et vos réponses vont servir à confection le fichier package.json
Par la suite les modifications du fichiers se font manuellement

package.json


Exemple de fichier


Le plus important est l'indication du point d'entrée 'main' du module qui sera repris par la commande require.
ici require('ETag')



Versionning avec git et hébergement par github (partie optionnelle)

A partir de la là les bonnes habitudes reviennent : ajouter un fichier .gitignore (le mien est très simple 1 seule ligne : *~ )


Puis lancer la commande 'git init' pour commencer à versionner votre code.

ok vous êtes sur des bons rails.

Pour le reste des  opérations de versionning j'utilise gitk (copie d'écran).

Le source du module sera géré par la forge github. Aussi la création d'un fichier README.MD pour avoir une page d'accueil bien lisible s'impose. L'extension md signifie MarkDown : c'est un langage qui permet d'écrire des pages de documentation plein texte qui seront automatiquement transformées en html.
Le lien suivant permet de se familiariser avec le MarkDown.


Voici le projet installé sur la forge github.


Le packaging


Un fois le module achevé, il suffira de créer une archive compressée (tgz)
L'archive doit contenir un répertoire nommé package qui accueillera votre module.

Avant de publier le module sur npm, un petit test en local s'impose en lançant la commande suivante
npm install nom_module.tgz

Publication du module sur npm


La première chose à faire et valable une bonne fois pour toute est de créer un compte pour npm par la commande suivante:
npm adduser

Afin la publication sera faite par :

npm publish mon_module.tgz
Ca y est votre premier module est sur npm:


Vos utilisateurs peuvent à présent faire npm install mon_module
(avec ou sans l'option -g) 

Les tests du module


Dans le but de faire un livrer un travail de qualité, il est bien de prévoir une batterie de test.
L'idée est d'avoir un point d'entrée pour exécuter des petits programmes de test. C'est le role du programme run.js du répertoire tests.

Le dispositif est complété par un Makefile qui permet d'automatiser le lancement des tests.


Ainsi la ligne du package.json



"scripts": {
        "test": "node tests/run.js"
    }


permet à vos utilisateurs de tester votre module par
npm test mon_module


En conclusion:  vous n'avez plus d'excuse pour ne pas publier vos modules sur npm.










lundi 26 mars 2012

La phase d'estimation dans les projets informatiques

La plannification de projet répond à une série de lois.

1) La loi Hostadter.

La plus connue est celle  Hofstadter. Cette loi énonce le principe suivant pour l'estimation d'une charge:
Cédric Villani : médaille Fields 

Ça prend toujours plus de temps qu'on croit, même en prenant compte de la loi de Hofstadter.

Ce qui veut dire : qu'il est difficile d'estimer correctement la charge d'un projet ET par l'emploi d'une formulation récursive : cette dificulté ne fait qu'augmenter pour tendre vers l'infini. reference: http://fr.wikipedia.org/wiki/Loi_de_Hofstadter 

2) La racine carrée comme pivot

A coté de cette loi très sérieuse on en trouve une autre pas mal : Après avoir estimer la charge totale d'un projet et faut aligner en face des ressources. 
Une technique pour calculer le bon équilibre entre la charge , la  durée et le nombre de personne est de prendre comme valeur la racine carrée de la charge: cette valeur constitue un point d'équilibre. Exemple : charge 36 mois/h , il faudra au maximum 6 personnes pour réaliser le projet. Il est possible de descendre en dessous de cette limite mais à l'inverse mettre plus de monde va ralentir le projet. Pour encadrer ces personnes , une septième personne (le chef de projet) sera nécessaire.
En conclusion : le gestion de projet agile reprend ces lois à son compte. Notamment, il est recommandé de passer très peu de temps sur l'estimation d'une charge. Plus on affine une estimation plus elle s'écartera de la réalité.  L'estimation ne doit pas se faire uniquement dans la phase d'avant projet.  Elle est partie intégrante du projet. Elle sera  réévaluée tout le long du projet . Elle sera fonction de la métrique des équipes : la vitesse d'avancement ramené au point de fonction. Aussi la loi de Germanlinux est la suivante: il n'est pas possible d'estimer correctement la charge d'un projet ....avant de l'avoir terminé (si on le termine un jour..) . Aussi mesurez ce qui a été fait et non pas ce qui reste à faire: c'est trop décourageant.

mercredi 21 mars 2012

Ceci est une console - non - un blog #design




Non ce n'est pas une console, c'est la page d'accueil du blog : http://www.steveklabnik.com/
Allez sur le site pour voir l'animation. Les fichiers sont des liens.

Le rédacteur  steve Klabnik est l'auteur d'un ouvrage intitulé: Designing Hypermedia APIs 


 "Hypermedia" (en bref les liens hypertextes ) et  "RESTful" ont donné naissance aux architectures 'HATEOAS' :Hypermedia as the Engine of Application State (explications ici). 
 Mais c'est une autre histoire..Je reviendrai sur ce sujet plus tard.




samedi 17 mars 2012

Tests de charge :3 fonctionnalités de jmeter à connaitre


Jmeter ou un projet  de la fondation Apache qui permet de réaliser des tests sur des applications WEB mais aussi sur des serveurs de messagerie, des annuaires LDAP ou encore des base de données (SQL).
 Ce programme en Java est très simple à installer : le telecharger et le lancer.

Voici 3 fonctionnalités de jmeter à connaitre:


1) Enregistrer vos scénarios de test avec jmeter.

Il n'est pas necessaire de partir de zéro pour réaliser ses plans de test avec jmeter.
jmeter dispose d'un mode 'enregistreur' qui lui permet de retracer votre navigation et de créer à la volée les éléments constituants le plan de test.
Pour cela il suffit d'ajouter dans son plan de travail un composant 'serveur proxy HTTP' et un contrôleur enregisteur en tant que fils (copie d'écran).


Après avoir lancé le proxy jmeter. Une reconfiguration de son navigateur s'impose pour lui faire utiliser ce proxy : dans le cas présent le proxy écoute sur 'localhost' port '8080'.

Puis, avec votre navigateur accédez à l'application à tester. Chaque requête viendra s'inscrire sous le composant enregisteur sous la forme de deux composants: La requete elle meme (GET et ressource) et un composant stockant les entetes HTTP.

On prendra soin à la fin de la session d'arreter le proxy et de faire glisser les éléments collectés du plan de travail au plan de test.(copie d'écran)



Des ajustements seront alors  nécessaires.


  • Le comportement d'un vrai utilisateur
Un utilisateur prend son temps pour lire une page et passer à la suivante. Les composants temporisateurs de jmeter servent à simuler ces transitions.
  •  La gestion du cache du navigateur. 
Si un testeur vient deux fois sur un site, son navigateur utilisera son cache pour les ressources statiques (images etc..) ainsi sa navigation, sera allégée
  • Les pages contenant de composants AJAX.
 jmeter ne saura pas tout seul reconnaître le bon fonctionnement du page sur le seul code retour. Il faudra ajouter un 'extracteur d'expression régulière' pour intercepter les réponses en JSON.(copie d'écran)




2) Réaliser des tests fonctionnels

Un case à cocher vous permet de basculer en mode 'test fonctionnel' (copie d'écran) . Dans ce cas, tous les échanges seront sauvegardés dans des fichiers. Ce mode sert à mettre au point un plan de test, à tester les expressions régulières ou tout simplement pour faire des tests de non régression. Ce mode ne doit pas etre activé pour des tests de charge car la taille des données collectées devient vite importante.

3) Faire des tests de chargement de fichier.

Jmeter peut d'envoyer des fichiers sur un site à tester.
Pour tester des uploads sur un site, les fichiers à envoyer doivent se trouver dans le système de fichier de l'injecteur.(copie d'écran) . Dans cette exemple, une varible '${C}' est associée à un compteur pour joindre à chaque itération un fichier different. (Important: Le nom des variables est en MAJUSCULE)


Pour terminer:

Un livre très bien sur jmeter. (lien ici)
Apache JMeter: A Practical Beginner's Guide to Automated Testing and Performance Measurement for Your Websites de Emily Halili (Broché - 30 juin 2008)

Un site sur jmeter en francais pour bien démarrer et plus encore: c'est une véritable mine d'information et de tutoriels sur jmeter  http://blog.milamberspace.net/index.php/jmeter-pages

J'utilise tous les jours jmeter pour tester l'efficacité des microserveurs node.js.  Node.js encaisse  800 ulploads simultanés sur un simple PC .



mercredi 14 mars 2012

#kanban et scrum pour les projets informatiques #agile

Vous connaissez le scrum ? La méthode agile, alors  vous allez adorer le 'Kanban' .  Et le meilleur des deux se trouve sur ce site:http://www.aubryconseil.com/post/Le-mini-livre-Scrum-et-Kanban-en-francais


Le lien suivant est celui d'un site qui propose un kanban en ligne et gratuit.
Ca donne un tableau comme ceci :
autre exemple:



Un retour d'expérience dans un prochain post.

lundi 12 mars 2012

Un autre livre sur #node.js en francais et gratuit

Pour bien commencer avec Node.js

La traduction francaise est ici.

La version  d'origine est disponible ici.

dimanche 11 mars 2012

module forever de #node.js: pour une production sure

Dans un post précédent j'ai évoqué le fonctionnement de Node.js. Il existe un module appelé 'forever' qui industrialise le lancement de script javascript pour Node.js.
L'installation se fait comme d'habitude par la commande

sudo npm -g install forever

Le résultat doit etre:


/usr/local/lib/node_modules/forever
├── pkginfo@0.2.3
├── timespan@2.0.1
├── watch@0.5.0
├── microtime@0.2.0
├── daemon@0.4.1
├── node-fork@0.4.2
├── nssocket@0.3.7 (eventemitter2@0.4.8 lazy@1.0.8)
├── cliff@0.1.7 (colors@0.6.0-1 eyes@0.1.7)
├── portfinder@0.2.1 (mkdirp@0.0.7)
├── optimist@0.2.8 (wordwrap@0.0.2)
├── broadway@0.1.13 (colors@0.6.0-1 eventemitter2@0.4.8 optimist@0.3.1)
├── minimatch@0.0.5 (lru-cache@1.0.5)
├── utile@0.0.10 (async@0.1.18 mkdirp@0.3.0 rimraf@1.0.9 ncp@0.2.5)
├── flatiron@0.1.14 (director@1.0.9-1 optimist@0.3.1 prompt@0.1.12)
├── nconf@0.5.1 (async@0.1.18 ini@1.0.2 optimist@0.3.1)
├── ps-tree@0.0.2 (parse-table@0.0.0)
└── winston@0.5.10



Le lancement d'un programme par forever est très simple :

forever start 'monprogramme.js'


Exemple :(commande start et list)

 forever start cluster1.js

info:   Forever processing file: cluster1.js

german@german-1001PX:~$

german@german-1001PX:~$ forever list

info:   Forever processes running

data:       uid  command script      forever pid  logfile                        uptime     

data:   [0] YJVa node    cluster1.js 2857    2858 /home/german/.forever/YJVa.log 0:0:0:7.882


Si le programme lancé par forever vient à tomber, il  sera relancer automatiquement.
Forever est lui même en mode daemon (on peut fermer son terminal de lancement) 

L'aide sur forever est la suivante:

L'article http://blog.nodejitsu.com/keep-a-nodejs-server-up-with-forever et le site de forever complètent mon propos.
Sur stackoverflow : un exemple d'usage de forever à l'intérieur d'un programme.

samedi 10 mars 2012

#node.js en cluster


Dans son mode de fonctionnement normal Node.js sera vu  par le système d'exploitation comme un programme mono-thread tournant sur un seul processeur. Ce mode d’exécution est optimum pour Node.js: il n'aura pas à partager des variables ni à synchroniser des threads. C'est plus une philosophie qu'une limite de Node.js.
Si vous avez  besoin de renforcer votre infrastructure en utilisant tous les processeurs,vous pouvez utiliser le module cluster. Ce dispositif permet de lancer le même  programme javascript sur plusieurs instances Node.js. Attention tous les programmes ne se prêtent pas à cette forme d'écriture et d'utilisation. Dans certains cas il sera nécessaire de mettre en place une communication inter-processus, mais c'est une autre histoire. L'installation se fait par


npm install -g cluster


Structure du programme.


La structure du programme est classique pour ce type d'utilisation :
La partie père du programme  accède à une fonction qui  retourne la liste des processeurs disponibles sur le PC. Puis en fonction du nombre, la partie père lance autant de fils que nécessaire. Dans l'exemple proposé, un numéro de PID pair d'un fils retourne un code OK '200', un numéro impair retourne une erreur '400'.
 


Après le lancement du script via node.js, la commande ps ax|grep node donnera:

 ps ax|grep node

 2596 pts/0    Sl+    0:00 node cluster1.js

 2598 pts/0    Sl+    0:00 /usr/local/bin/node /home/german/cluster1.js

 2599 pts/0    Sl+    0:00 /usr/local/bin/node /home/german/cluster1.js



La première ligne correspond au job du père, les deux autres aux  fils. Ce sont eux qui prennent indifféremment les connexions entrantes.
En cas de perte d'une instance le flux sera pris par la deuxième.
Les règles de répartion sont gérées par l'OS.
La fonction cpus donne sur ma machine:



[ { model: 'Intel(R) Atom(TM) CPU N450   @ 1.66GHz',
    speed: 1667,
    times:
     { user: 1768110,
       nice: 31500,
       sys: 936040,
       idle: 2281930,
       irq: 160 } },
  { model: 'Intel(R) Atom(TM) CPU N450   @ 1.66GHz',
    speed: 1667,
    times:
     { user: 1753240,
       nice: 40410,
       sys: 910150,
       idle: 2252070,
       irq: 140 } } ]


Tests avec jmeter

J'ai utilisé le projet libre jmeter pour tester le bon fonctionnement du dispositif.
Les copies d'écran présentent le plan de charge et le résultat de son exécution. 
Le plan de test

En  vert les codes retour 200 (OK)  en rouge les codes 400 (erreurs)


La aussi pas de surprise: plus la taille de l'échantillon augmente et plus la répartition est proche de la médiane.

En conclusion: Le mode cluster est à réserver pour un usage limité. Si on recherche de la tolérance de panne, le module forever sera plus adapté.

mardi 6 mars 2012

Livres gratuits #node.js

Sur amazon : un livre gratuit consacré à Node.js.
Lien ici....


Un autre ici..... Mastering Node.js

lundi 5 mars 2012

Programmez - mars 2012 (150) #coffeescript #jQuery

Dans le dernier numéro de Programmez : (numéro 150) .


Le titre du dossier est prometteur et  bonne nouvelle : il tient ses promesses.

Au sommaire:

  • Un très bon article sur coffeescript : ce langage permet aux développeurs 'coté serveur' de programmer en javascript comme des développeurs 'coté client'. L'article prend un exemple en java et le porte en coffeescript.
  • Une introduction au langage 'R' . R est le langage de programmation des statistiques.
  • Une guide pour bien démarrer avec jQuery.
  • Hadoop et du javascript .. 

samedi 3 mars 2012

Une semaine sur #Pinterest

J'ai essayé le nouveau truc à la mode qui s'appelle 'pinterest'.


 Nous sommes nombreux à coller des choses sur la porte du frigo.

 Avec pinterest vous disposez d'une immense porte de frigo ou d'un tableau magnétique géant pour accrocher des photos ou des vidéos. Il est possible d'organiser par thème ses tableaux. Ce site connait un gros succès avec un nombre d'utilisateur croissant (> à 10 millions) . Son public est majoritairement féminin.

Pourt suivre mes tableaux : c'est ici.  Je m'en sert pour conserver des illustrations au fur et à mesure de mes explorations. Pour 'punaiser' plus facilement, il est recommander d'ajouter le composant pinterest à son navigateur.




vendredi 2 mars 2012

#Ruby sur #android avec ruboto


Réaliser une simplement application pour android 

Remarque préalable.
Les smartphones sont divisés en deux familles les iphones sur IOS et les android.
La technologie à privilégier sur Iphone pour réaliser une application est objective-C.

Sur ANDROID , c'est le langage JAVA qui est utilisé. La pile java sur Android est différente de celle de votre PC. Sur un PC le schéma classique est le suivant: 
Confection d'un source java 
Compilation par le programme javac afin d'obtenir un fichier  de type pseudobyte  (.class) qui sera interprété par une JVM.

Sur ANDROID, le pseudobyte est à son tour compilé pour obtenir un fichier 'dex' interprété non pas par la JVM mais par un dispositif semblable : dalvik
conclusion intermédiaire: une application en  objective-c sera plus performante que son équivalant sur ANDROID. Son code est compilé, directement exécutable.
Source: 
http://www.technomicon.com/ElectroPolitics/ElectroPolitics-11-15-10.html

Installation sur le PC.
Pour ANDROID, le développement se fait sur un PC doté d'un kit de développement complété le plus souvent d'un émulateur de smartphone. Cet émulateur permet de tester très simplement et en toute sécurité vos applications sans avoir recours à un vrai smartphone.
L'outil privilégié pour réaliser tout ça est le plus souvent l'IDE éclipse avec les extensions pour ANDROID.

Il existe une solution alternative avec Ruby et RUBOTO. A l'origine tout commence par jruby, ce projet permet d'écrire des programmes en Ruby qui seront exécutés sur une JVM.  A partir d'un source Ruby, Jruby génère le bytecode qui sera interprété par la JVM. Le projet RUBOTO fourni plusieurs fonctionnalités: 
a) Génération de squelette d'application pour ANDROID
b) Outils pour créer un fichier directement en pseudo-code dex. Jruby intervient  pour la partie amont de traduction du source Ruby en pseudo-code java.  
c) Les librairies à installer sur le système ANDROID pour faire fonctionner les applications RUBOTO.

Le guide de démarrage du site RUBOTO donne la marche à suivre pour obtenir votre première application.
Les principales étapes sont les suivantes:

Les prérequis:
  • installation du
  • installation de jruby
  • SDK ANDROID
  • installation d'un émulateur ANDROID.
L'installation de jruby peut se faire avec l'utilitaire rvm (Ruby Virtual Machine). Pour le reste suivre la documentation du site RUBOTO. Tout fonctionne parfaitement sous Ubuntu
Sur votre ANDROID.

Il faudra récuperer le 'ruboto core' : c'est l'ensemble des librairies utilisées pour faire tourner vos application. L'installation se fait par l'android market. (copie d'écran) 

Un autre utilitaire sera necessaire pour faire passer votre application de votre PC à votre téléphone. J'ai utilisé l'application 'Apk Installer'  toujours par l'android market 

 Après avoir relié le smartphone au PC par le cable USB, il suffira de déposer le programme-archive (.apk)  dans l'arborescence de la SD.  L "APk installer" sera alors capable d'installer l'application comme si elle était issue de l'android market.

Un projet RUBOTO propose des dossiers pour ranger les ressources de l'application (icones).





L'application est ici: 


Elle ressemble à ceci:
L'émulateur  donne cet écran:


La doc  de Ruboto détaille comment accéder aux informations du GPS ou du wifi.

En conclusion:

Dans le cas présent on est dans le domaine des applications de type 'client lourd'.
Réaliser une application de type client léger serait encore plus simple (et plus portable)  mais il manquerait l'accès aux ressources locales (GPS, wifi etc) . L'annonce du portage de chrome sur Android est très importante. Car chrome vient avec son moteur javascript 'V8'.  L'objectif d'avoir un serveur web local léger comme node.js se rapproche.