Page de Geek

Thème ParisInBlue pour MacVim

Je viens de publier un nouveau thème pour vim. Toujours principalement destiné à coder en Ruby même si ok sur d’autres languages.
Il est téléchargeable ici: vim parisinblue.

Thème ParisInLove pour MacVim

Je viens de publier un thème pour vim. Principalement destiné à coder en Ruby et avec RubyOnRails.
Il est téléchargeable ici: vim parisinlove.

Google bot est passé

Ce weekend, après la nouvelle version du blog, j’ai réussi à faire venir Google Bot assez rapidement. La preuve, je l’ai même pris en photo ;)

Vous pouvez retrouver d’autres éléments en papier sur: Sloth Paper Toys ROMMY

Coup de pinceau

Vous l’aurez constaté, j’ai complétement redessiné le design du blog.
Je souhaitai rester sur une approche très verticale facilitant la lecture des articles. Je pense que cet objectif est atteint.
Concernant le design, il reste clair et exploite des textures rappelant des tissus et donnant, j’espère, un effet “rétro”. J’ajouterai bientôt quelques nouveaux éléments dans le même esprit permettant de donner plus de profondeur.

Multiples connexions avec ActiveRecord

Il y a quelque jours j’étais tombé sur un article présentant une technique permettant à du code Ruby de s’interconnecter, en exploitant Active Record, à plusieurs bases de données. Ceci peut être très intéressant lorsqu’on a du code backend ou de gestion de données en tache de fond. Ou encore, lors de reprises de données. Il est par exemple possible de charger des objets sur une base MySQL et avec d’autres sur du Posgres. Par contre niveau performance, il ne faut pas se voiler la face, ce n’est pas la meilleure solution.

Je livre donc le code tel quel. Dans mon exemple, on a bien entendu sur la db1 une table « articles » avec une colonne « category_id », et sur la db2 une table « categories ».

db_one:
  adapter: mysql2
  host: localhost
  username: root
  password: 
  database: db1
  encoding: utf8

db_two:
  adapter: mysql2
  host: localhost
  username: root
  password: 
  database: db2
  encoding: utf8

require 'yaml'
require 'active_record'

# récupération du fichier de configuration des bases de données
$config = YAML.load_file(File.join(File.dirname(__FILE__), 'config.yml'))

# définition des bases de données
class Db1 < ActiveRecord::Base
  self.abstract_class = true
  establish_connection $config['db_one']
end
class Db2 < ActiveRecord::Base
  self.abstract_class = true
  establish_connection $config['db_two']
end

# définition des objets métier. Ils héritent de Db(x)
class Article < Db1
  belongs_to :category
end
class Category < Db2
  has_many :articles
end

# utilisation des objects
Article.all.each do |article|
  puts "- #{article.title} (#{article.category.title})"
end

Avantage de Map Reduce

Depuis déjà quelques temps le Big Data est la mode. Certains font un discours commercial sur ce sujet, d’autres en font une véritable rupture technologique. Certains le résument à de la visualisation graphique… Quelque soit les points de vue, il s’agit toujours de problématiques reposant sur le traitement de données volumineuses.

D’un point de vue très technique, il existe plusieurs techniques pour traiter des données massives. L’une d’elle se nomme Map/Reduce que je vais essayer de présenter ici en utilisant Ruby.

Wikipedia nous dit que Map/Reduce correspond à un framework présenté par Google et permettant d’effectuer des traitements parallèles le plus souvent distribués sur plusieurs machines. Par données volumineuse, il faut comprendre > à 1 To.

Dans cette définition, le terme framework me gêne. En effet, il existe des technologies comme Hadoop implémentant Map/Reduce et proposant différents services supplémentaires. Toutefois, à mon sens, je considère plus Map/Reduce comme une approche, voir un Pattern, plus qu’un framework « clé en main ».
Je vais essayer de montrer que Map/Reduce peut être implantée « facilement » sans avoir recours à un framework.
Lors du traitement massif de données, le développeur doit changer son point de vue sur ses travaux, ses techniques et ses « outils ». En effet, la conception d’un système devant traiter xTo de données, qui vont surement augmenter dans le temps, n’est pas la même chose que de développer une application web reposant sur une base de données classique proposant des systèmes d’index. A ce niveau des enjeux de scalabilité doivent aussi être pris en compte. C’est ce que permet Map/Reduce.

Le problème en détail

Admettons que j’ai un corpus de données à traiter. Il s’agit de tweets.
Pour résumer ces données je veux me concentrer sur les hashtags qu’ils comportent. C’est à dire les extraire et les compter. Ceci me permettra par exemple de voir ceux qui font le plus « buzz » sur un période de temps.
La logique voudrait que je réalise une « petite boucle » qui passe en revue chaque tweet, leur applique une fonction de traitement (voir de normalisation et de nettoyage), puis extrait les hashtags vers un tableau.

Le problème est que le nombre de tweets est plutôt important. Le fichier se compte en Go de données (pour info. ce chiffre est rapidement atteignable avec l’API Twitter). La solution sera donc d’augmenter la taille de la machine de traitement. Ce qui augmentera les performances de « ma boucle ». Admettons que je puisse traiter 1Go de tweets en 5 secondes.

J’ai codé cette approche au sein d’un projet sur Github :
one_big_file.rb

Ce code se contente de charger en mémoire un fichier « important » et d’extraire chaque tweet. Point important : les contraintes de temps de traitement d’un fichier « important » sont codées par une classe de simulation. J’allais tout de même pas pousser 1Go de données sur Github :).

Problématique supplémentaire importante : dans le futur ce corpus de données va obligatoirement augmenter avec le nombre de tweets toujours plus important. Ce qui pose problème à ce niveau, c’est qu’il n’y a pas de limite de volumétrie des données mais une limite sur la taille des machines de traitement sur lequel on ne peut pas agir.

Map/Reduce permet de répondre de façon intéressante à ce problème.
Ci-dessus nous avons admis qu’il est possible de traiter 1Go de tweets en 5 secondes. Je souhaite réduire le temps de traitement total acceptable à une seconde. Par hypothèse, je vais donc « splitter » ce fichier volumineux en 5 autres plus petits.
Il s’agit donc de découper le problème en sous-problèmes puis de les déléguer (fonction Map) à des « nœuds » indépendants (de préférence répartis sur plusieurs machines). Chaque nœud, remontera ses résultats au nœud parent.
Par la suite, il va falloir « réduire » (fonction Reduce) chaque résultat et reconstruire un résultat commun dans la forme attendue.
C’est le code présenté ici :
map_reduce_with_threads.rb

Dans ce fichier source, le temps de traitement des petits fichiers est aussi simulé. J’ai exploité les threads pour « distribuer » les traitements sur plusieurs nœuds. Chaque thread est en quelque sorte un nœud. Il est important de noter que dans la vie réelle, chaque nœud devrait être sur une machine séparée. Ceci aurait plusieurs avantage : si une machine tombe, une autre peut prendre le relai. De plus, si la volumétrie de données augmente, il suffit d’ajouter des machines.
Les threads ne seraient donc pas utilisés.

Pour conclure, dans ce billet, j’ai essayé de présenter l’approche Map/Reduce qui répond vraiment aux problématiques actuelles.

Globalement, le code source peut être cloné (https://github.com/PagedeGeek/map_reduce_poc.git) et testé en utilisant le fichier bin/hashtags.rb avec différents paramètres.

Ce client exploite quelque chose proche d’un design pattern Strategy en mesure de charger les deux approches présentées ci-dessus : chargement par un seul fichier volumineux, ou par un plusieurs plus petits fichiers.
J’essaierais d’implémenter rapidement une troisième stratégie reposant sur un véritable système de distribution de taches. Au hasard : Redis :)

Revue de liens

Voici quelques liens que j’ai partagé cette semaine sur différents réseaux:

[Text Mining] pg_similarity is an extension to support similarity queries on PostgreSQL
[Data Analysis] Tracking US Sentiments Over Time In Wikileaks
[Web-Marketing] Le Marketing Intelligent dépoussière le marketing relationnel
[SEO] La personnalisation des résultats expliquée
[Startups] Pourquoi les startups échouent-elles ?
[Search Engine] Le moteur de recherche d’Apache Lucene et son projet Solr
[Techno.] Redis Cookbook

Mode Vintage de Sublime Text 2

Mon passage sous Mac remonte à 2006 avec l’arrivée des MacBook Pro sur la base d’architecture Intel.

Depuis ce temps, je n’ai jamais quitté cette plateforme. Auparavant, j’ai longtemps utilisé Linux. Principalement avec les distributions Fedora. Je me souviens être longtemps resté sur une Fedora Core 4 supporté par un vieux ThinkPad d’IBM. Le couple avait le mérite d’être increvable. Tous les pilotes fonctionnaient à merveille, la puissance était vraiment à l’ordre du jour.
Sur cet environnement, j’ai un peu utilisé Eclipse, travaillant sur les technologies Java, JEE notamment avec la sortie des EJB3 ; mais j’ai très souvent exploité VIM pour éditer du code source.

Sur Mac, j’ai suivi l’effet de mode. Je me suis mis à Textmate. Cet éditeur par sa philosophie est plus proche de Vim que d’Eclipse. Il avait le net avantage d’être très léger et proposer une richesse fonctionnelle impressionnante. La productivité offerte par Textemate est rendue possible grâce à sa quantité importante et intelligente de raccourcis clavier, de snippets et autres systèmes customizable.

Avantages de Vim

Vim offre une fonctionnalité que j’ai longtemps exploitée mais que, malheureusement, TextMate ne propose pas. Il s’agit du Split de fenêtre.
Par exemple, le Split Vertical permet d’ouvrir deux pages de source afin de les éditer en même temps. Cette fonctionnalité est extrêmement pratique dans le cadre du développement de tests unitaires. En effet, sur la split principal j’aime avoir le code source de travail puis sur l’autre partie mes tests unitaires correspondant à ce code. Ce qui permet de switcher rapidement entre les deux au moyen d’un seul coup d‘œil sans avoir besoin de changer d’onglet.
Sous Ruby on Rails, avoir sur le split principal ses controller, puis l’autre split de ses vues est ausi une bonne idée. Dans un autre onglet, on peut imaginer avoir ses models ainsi que ses tests unitaires sur deux splits différents.
Je ne vais pas rentrer dans les détails. Chaque développeur à ses petites manies. Quoiqu’il en soit l’exploitation du mode splits permet d’être productif.

Au delà de cette fonctionnalité ergonomique, Vim à la particularité d’offrir à l’utilisateur deux modes. Le mode édition et le mode visualisation. Le premier mode propose d’éditer son code source de la même façon que tous les autres éditeurs en proposant même un système de complétion automatique. Le second mode, très difficile à prendre en main, mais tellement puissant, permet à l’utilisateur d’agir sur son code source au moyen de raccourcis clavier en laissant complémentent de coté la souris. Par exemple : se déplacer dans le code source au moyen des touches H, J, K, L, etc.
Je ne rentre pas non plus dans les détails, beaucoup d’articles discutent sur la nécessité de cette approche et en quoi elle est bénéfique pour les développeurs.

Inconvénient de Vim sous Mac

Cependant, Vim sous Mac, particulièrement avec MacVim, a le désagréable problème de ramer légèrement lorsque le code source fait plus de 300 lignes de code. Je ne connais pas vraiment l’origine de ce problème. Toutefois, une utilisation quotidienne permet de ressentir ce souci qui dans certains cas peut devenir rapidement agaçant.

Sublime Text 2 mode Vintage

Un ami (Florien tu te reconnaitras), m’a souvent parlé de Sublime Text 2.
Cet éditeur de code source propose, à la différence de TextMate, le split vertical et horizontal. Pour le reste, ils sont sensiblement équivalent : léger, riche sur le plan fonctionnel et customizable.

En rentrant un peu en profondeur dans les capacités de Sublime Text 2, j’ai découvert que cet éditeur de code proposait le mode « Vintage » !
Ceci correspond tout à fait à ce que Vim propose. C’est à dire la possibilité d’avoir deux modes : visualisation et édition.

Le mode Vintage de Sublime Text 2 peut être activé au moyen de l’édition des dernières lignes du ficher de configuration par défaut. Il suffit de le retirer des packages ignorés. Ce qui donne :

// List any packages to ignore here. When removing entries from this list,
// a restart may be required if the package contains plugins.
"ignored_packages": [],
"vintage_start_in_command_mode": true

Dès lors, il est possible dans Sublime Text 2, d’avoir accès aux capacités spéciales des deux modes. Dorénavant, vous pouvez vous déplacer grâce aux touches HJKL. Vous déplacer entre plusieurs mots avec E, W, B, etc.

Vous pouvez aussi étendre les raccourcis clavier. Par exemple pour switter entre les splits verticaux, changer l’accès au système de complétion automatique, jouer avec la sidebar, etc.
Ce qui donne pour moi, dans le fichier User Key Binding :

// { "keys": ["ctrl+l"], "command": "focus_group", "args": {"group": 1}},
{ "keys": ["ctrl+l"], "command": "next_view"},
// { "keys": ["ctrl+h"], "command": "focus_group", "args": {"group": 0}},
{ "keys": ["ctrl+h"], "command": "prev_view"},
{ "keys": ["ctrl+k"], "command": "scroll_lines", "args": {"amount": 15.0} },
{ "keys": ["ctrl+j"], "command": "scroll_lines", "args": {"amount": -15.0} },

{ "keys": ["super+shift+k"], "command": "toggle_side_bar"},
{ "keys": ["super+shift+h"], "command": "focus_side_bar"},
{ "keys": ["super+shift+l"], "command": "focus_group", "args": {"group": 0}}

Petit bonus

Je vous propose aussi une nouvelle icone Sublime Text 2 (version Mac). Version Windows

</>

Pousser ses logs Ruby dans Redis

Il y a quelques mois j’ai réalisé un billet sur les avantages d’utiliser Logger avec Ruby plutôt que les méthodes « puts ».
Je présentais qu’il était aisément possible d’implémenter un « Logger Device » en mesure d’absorber les logs puis de les traiter par exemple en les injectant dans une base sqlite3.

Hier soir, j’ai réalisé un Gem facilitant ce travail dans le but de pousser les logs dans une Queue Redis.
Son utilisation est très simple. Il faut 1° mettre en place le device dans son code lors de la création du logger, puis dans un second temps coder un worker qui viendra régulièrement traiter les logs. Dès lors, il est possible de lancer différents workers en parallèle.

Pour l’installer, la procédure est classique:
$ gem install redis_logger_device

Code d’utilisation

require 'logger'
require 'redis_logger_device'

dev = RedisLoggerDevice::Base.new
logger = Logger.new(dev)

logger.info("AAAAAaaaaaahhhhh")

logger.close

Un simple Worker

Attention, ce code traite les logs de la queue redis mais exploite aussi un logger en STDOUT (worker_logger) qui n’a rien à voir avec le premier. A ne pas confondre :)

require 'logger'
require 'redis_logger_device'

include RedisLoggerDevice

class SimpleLogWorker < LogWorker
  def process_queue!
    loop do
      begin
        @logger.info("LogWorker fetching (#{@queue_name})...")
        key, val = @redis.brpop @queue_name
        @logger.info("LogWorker rocess key: #{key}; val: #{val}")

        #your code : val = log entry

      rescue SignalException => e
        raise e
      rescue Exception => e
        @logger.fatal "LogWorker error: #{e.message}"
        raise e
      end
    end
  end
end

worker_logger = Logger.new(STDOUT)
worker = SimpleLogWorker.new(worker_logger)

worker.process_queue!

worker_looger.close

Ce Gem est fonctionnelle. Il exploite le mode ‘List’ de Redis. Je pense cependant apporter quelques améliorations rapidement, notamment en expoitant le mode PubSub.

Diffusion de liens

Ce blog me permet depuis presque un an de partager différents points de vu technique notamment concernant les bonnes pratiques de développement (Design Pattern, tests unitaires, etc.), les technologies liées à l’univers Ruby, Big Data, NoSQL, Calculs distribués, sécurité et d’autres thématiques.

J’essaie de détailler au maximum mes billets. Cependant, au regard du temps passé sur ces publications, je pense diffuser de plus en plus de liens brutes, sans trop d’analyse. Les thématiques resteront donc les mêmes mais seront d’avantages ouvertes vers le Web Analytics et le SEO.
Je commence donc par ces élélements:

Exercice de scalabilité avec Ruby et Redis

Il y a quelques jours, j’ai découvert un peu par hasard que certains des flux RSS que je suivais étaient mort ou avaient changé d’url.

Malheureusement peu d’outils (dont Google Reader) informent l’utilisateur de ce problème.
Lorsque l’on fait de la veille, c’est très embêtant de penser suivre un corpus de flux rss quand bien même ils peuvent changer.

Prenant le train, je me suis mis à coder rapidement un p’tit outil en mesure de détecter les éventuels flux morts.
En effet, je souhaitais identifier les flux provoquant une erreur HTTP (404 et autre) ou ne proposant plus aucun article.

Avec Ruby il existe la Gem feedzirra et la lib standard RSS. Pour des raisons pratiques, j’ai choisi… les deux :)
En effet, j’ai eu du mal à me décider. J’ai donc appliqué le Design Pattern Strategy en mesure de sélectionner l’une ou l’autre méthode de collecte de flux RSS.

Avec quelques méthodes d’import de flux à partir d’un fichier OPML, ca donne ce code :

require 'logger'
require 'rss'
require 'nokogiri'

class FeedsEngine
  def initialize(logger, bad_feeds_logger)
    @logger = logger
    @bad_feeds_logger = bad_feeds_logger
  end

  def process(url)
    raise NotImplemented
  end

  def self.build(logger, bad_feeds_logger, engine=StandardEngine)
    return engine.new(logger, bad_feeds_logger)
  end
end

class FeedzirraEngine < FeedsEngine
  require 'feedzirra'

  def process(url)
    res = -1

    begin
      @logger.info("Process url #{url}")
      feed = Feedzirra::Feed.fetch_and_parse(url)
      @logger.info("Url processed: #{url}")

      if feed == 404
        raise "Error 404"
      else
        feed.entries.each do |entry|
          @logger.info("Entry found: #{entry.title}")
        end
        res = feed.entries.size
        @logger.info("#{res} entries in #{url}")
      end

    rescue SignalException => e
      raise e
    rescue Exception => e
      @logger.warn("Warning: #{url} => #{e.message}")
      @bad_feeds_logger.info("#{url}")
      res = -1
    end

    return res
  end
end

class StandardEngine < FeedsEngine
  def process(url)
    res = -1

    begin
      @logger.info("Process url #{url}")
      content = open(url){|s| s.read}
      @logger.info("Url processed: #{url}")

      rss = RSS::Parser.parse content, false
      rss.items.each do |entry|
        @logger.info("Entry found: #{entry.title}")
      end
      res = rss.items.size
      @logger.info("#{res} entries in #{url}")

    rescue SignalException => e
      raise e
    rescue Exception => e
      @logger.warn("Warning: #{url} => #{e.message}")
      @bad_feeds_logger.info("#{url}")
      res = -1
    end

    return res

  end
end

class OpmlImporter
  def initialize(filename, logger)
    @logger = logger
    @filename = filename
  end

  def urls
    urls = []
    begin
      @logger.info "OpmlImporter open file: #{@filename}"
      outlines = Nokogiri::HTML(open(@filename)).search('outline')
      outlines.each do |outline|
        url = outline['xmlurl']
        unless url.nil?
          @logger.info "OpmlImpoter add url: #{url}"
          urls << url 
        end
      end 

    rescue Exception => e
      @logger.error("OpmlImporter error: #{e.message}")
    end
    return urls
  end

end

class Cli
  def initialize(opml_filename, log_level_str='info')
    begin
      raise "use ./feedschecker.rb OPML_FILENAME LOG_LEVEL" if opml_filename.nil? || opml_filename.length == 0

      log_level_str = 'info' if log_level_str.nil?

      logger = Logger.new(STDOUT)
      logger.level = Logger::INFO  if log_level_str.downcase == 'info'
      logger.level = Logger::WARN  if log_level_str.downcase == 'warning'
      logger.level = Logger::ERROR if log_level_str.downcase == 'error'

      bad_feeds_logger = Logger.new File.open('./bad_feeds.txt', 'a')
      bad_feeds_logger.level = Logger::INFO

      engine = FeedsEngine.build(logger, bad_feeds_logger)

      OpmlImporter.new(opml_filename, logger).urls.each do |url|
        engine.process url
      end

    rescue SignalException => e
      puts ''
    rescue Exception => e
      logger.warn "ERROR: #{e.message}"
      logger.error "#{e.backtrace}"
      logger.error "#{e.inspect}"
    end

    bad_feeds_logger.close unless bad_feeds_logger.nil?
    logger.close unless logger.nil?
  end
end

Cli.new ARGV[0], ARGV[1]

Points d’amélioration avec le multihreading

Ce code fonctionne assez bien lorsque l’on analyse une centaine de flux RSS. L’outil tourne sur chaque élément, réalise les requêtes http, traite les résultats, puis pousse les retours d’erreurs vers l’utilisateur.

Cependant à partir de 1000 flux RSS, ce fonctionnement commence à devenir un peu (trop) long.
Les délais de traitement les plus grand sont sur la couche de communication réseau. Certains serveurs répondent rapidement, d’autres avec des délais plus long.

L’idée est donc de paralléliser les traitements en exploitant les modes multithreading ou une approches à base de processus système.
Ceci afin de ne pas engendrer de blocage et de latence par les serveurs les plus médiocre.

L’approche classique serait de modifier le code afin de mettre en place des pool de flux RSS importés puis de lancer des threads (ou processus) en parallèle afin de diminuer les temps de collecte. Les threads seront à privilégier car étant plus léger et moins gourmant que les processus système.

Toutefois, j’ai choisi une approche de parallélisassions des traitements différente.

Distribution, parallélisassions et scalabilité avec Redis

J’ai fait le choix d’utiliser un système reposant sur une Queue centrale en mesure du distribuer les taches à effectuer aux différents systèmes de collecte et de traitement.

Ceci à l’énorme avantage de faciliter la scalabilité horizontale et donc de répartir les travaux sur plusieurs machines (et aussi sur plusieurs réseaux mais c’est une autre histoire :).

Avec cette approche, on peut découper les traitements. Il est possible d’avoir des systèmes dédiés à la collecte des flux RSS, d’autres aux calculs.
Dans notre cas, seul compte l’identification du nombre d’articles par flux rss et la détection d’erreur. Toute « l’intelligence » peut donc être concentrée dans chaque sous-système, au même endroit.

De plus, avoir un système facilitant la scalabilité horizontale permet de gérer en temps réel l’activité de plusieurs machines. Par exemple, si le nombre de flux rss augmente rapidement il est possible d’allouer dynamiquement des ressources permettant de faire face à cette charge ponctuelle.
Au contraire si le nombre de flux rss à analyser est faible, on peut transformer des systèmes initialement dédiés à la collecte, aux activités de traitement.

Je ne détail pas le fait que le système est très flexible face aux pannes.

L’architecture repose donc sur la mise en place d’un serveur Redis faisant office de Queue.
Afin de contenir d’éventuels problèmes techniques, ce serveur peut être identifié comme Master et faire appel à des Slaves dans une architecture en cluster par exemple. Je ne détail pas, Google est votre ami :)

Le serveur Redis peut aussi être installé sur sa machine en local, ou sur un serveur situé sur le réseau. Il peut très bien être déporté sur internet.
Par exemple grâce aux services en ligne http://redis4you.com/ et http://redistogo.com/.

Grâce à ce dernier point, on peut très bien imaginer les systèmes de traitement répartis sur plusieurs machines aux quatre coins de la terre sur plusieurs réseaux.

Ci-dessous, le code intégrant les capacités de distribution et de parallélisassions sur plusieurs machines.
Bien entendu, ce n’est pas un code final.
Il est nécessaire de mieux gérer les logs, les paramètres, la mémoire et mériterait un peu de refactoring :)

Pour importer les flux: ruby feedschecker_cluster.rb -i ~/fichier.opml

Pour connaitre la taille de la pile: ruby feedschecker_cluster.rb -s

Pour lancer un Worker sur la pile en cours: ruby feedschecker_cluster.rb -w
il bien entendu possible de lancer plusieurs worker sur la même machine.

require 'logger'
require 'rss'
require 'nokogiri'
require 'redis'

class FeedsEngine
  def initialize(logger, bad_feeds_logger)
    @logger = logger
    @bad_feeds_logger = bad_feeds_logger
  end

  def process(url)
    raise NotImplemented
  end

  def self.build(logger, bad_feeds_logger, engine=StandardEngine)
    return engine.new(logger, bad_feeds_logger)
  end
end

class FeedzirraEngine < FeedsEngine
  require 'feedzirra'

  def process(url)
    res = -1

    begin
      @logger.info("Process url #{url}")
      feed = Feedzirra::Feed.fetch_and_parse(url)
      @logger.info("Url processed: #{url}")

      if feed == 404
        raise "Error 404"
      else
        feed.entries.each do |entry|
          @logger.info("Entry found: #{entry.title}")
        end
        res = feed.entries.size
        @logger.info("#{res} entries in #{url}")
      end

    rescue SignalException => e
      raise e
    rescue Exception => e
      @logger.warn("Warning: #{url} => #{e.message}")
      @bad_feeds_logger.info("#{url}")
      res = -1
    end

    return res
  end
end

class StandardEngine < FeedsEngine
  def process(url)
    res = -1

    begin
      @logger.info("Process url #{url}")
      content = open(url){|s| s.read}
      @logger.info("Url processed: #{url}")

      rss = RSS::Parser.parse content, false
      rss.items.each do |entry|
        @logger.info("Entry found: #{entry.title}")
      end
      res = rss.items.size
      @logger.info("#{res} entries in #{url}")

    rescue SignalException => e
      raise e
    rescue Exception => e
      @logger.warn("Warning: #{url} => #{e.message}")
      @bad_feeds_logger.info("#{url}")
      res = -1
    end

    return res

  end
end

class OpmlParser
  def initialize(filename, logger)
    @logger = logger
    @filename = filename
  end

  def urls
    urls = []
    begin
      @logger.info "OpmlImporter open file: #{@filename}"
      outlines = Nokogiri::HTML(open(@filename)).search('outline')
      outlines.each do |outline|
        url = outline['xmlurl']
        unless url.nil?
          @logger.info "OpmlImpoter add url: #{url}"
          urls << url 
        end
      end 

    rescue Exception => e
      @logger.error("OpmlImporter error: #{e.message}")
    end
    return urls
  end

end

class Worker
  QUEUE_SCHEME = 'feedschecker:queue'
  
  def self.push_url(url)
    redis = Redis.new
    redis.lpush QUEUE_SCHEME, url
    redis.quit
  end

  def self.queue_size
    s = -1
    redis = Redis.new
    s = redis.llen QUEUE_SCHEME
    redis.quit
    return s
  end

  def initialize(engine=StandardEngine)
    @redis = Redis.new

    @logger = Logger.new(STDOUT)
    @logger.level = Logger::INFO

    @bad_feeds_logger = Logger.new(STDOUT)
    @bad_feeds_logger.level = Logger::INFO

    @engine = FeedsEngine.build(@logger, @bad_feeds_logger, engine)

    work!

    @redis.quit
    @logger.info("Close redis connexion")
    @logger.close
    @bad_feeds_logger.close
  end

  def pop_feed_url
    @logger.info("Worker pop url...")
    return @redis.brpop(QUEUE_SCHEME, 0)[1]
  end

  private
  def work!
    loop do

      begin

        url = pop_feed_url
        @logger.info("Worker process url: #{url}")
        @engine.process(url)

      rescue SignalException => e
        raise e
      rescue Exception => e
        @logger.warn("Worker.work! error: #{e.message}")
      end

    end
  end
end

class Cli
  def initialize(opml_filename, log_level_str='info')
    begin
      raise "use ./feedschecker.rb OPML_FILENAME LOG_LEVEL" if opml_filename.nil? || opml_filename.length == 0

      log_level_str = 'info' if log_level_str.nil?

      logger = Logger.new(STDOUT)
      logger.level = Logger::INFO  if log_level_str.downcase == 'info'
      logger.level = Logger::WARN  if log_level_str.downcase == 'warning'
      logger.level = Logger::ERROR if log_level_str.downcase == 'error'

      bad_feeds_logger = Logger.new File.open('./bad_feeds.txt', 'a')
      bad_feeds_logger.level = Logger::INFO

      engine = FeedsEngine.build(logger, bad_feeds_logger)

      OpmlParser.new(opml_filename, logger).urls.each do |url|
        engine.process url
      end

    rescue SignalException => e
      puts ''
    rescue Exception => e
      logger.warn "ERROR: #{e.message}"
      logger.error "#{e.backtrace}"
      logger.error "#{e.inspect}"
    end

    bad_feeds_logger.close unless bad_feeds_logger.nil?
    logger.close unless logger.nil?
  end
end

# Cli.new ARGV[0], ARGV[1]

if ARGV[0] == '-i'
  logger = Logger.new(STDOUT)
  logger.level = Logger::INFO

  OpmlParser.new(ARGV[1], logger).urls.each do |url|
    logger.info("Push url: #{url}")
    Worker.push_url(url)
  end

  logger.close
end

if ARGV[0] == '-s'
  puts "#{Worker.queue_size} entries in queue"
end

if ARGV[0] == '-w'
  worker = Worker.new
  worker.work!
end

Quelques fonctions Ruby sur les Array

Initialement Ruby propose de nombreuses solutions pour manipuler des données. J’ai regroupé ci-desous quelques fonctions très utiles et parfois peu connues.

# --- Définition des Array
array1 = ['Array 1 - row 1',
          'Array 1 - row 2',
          'Array 1 - row 3']

array2 = ['Array 2 - row 1',
          'Array 2 - row 2',
          'Array 2 - row 3',
          'Array 2 - row 4']

# --- méthode ZIP. Permet de parcourir en même temps deux Array
array1.zip(array2).each do |row_array1, row_array2|
  puts '-'*30
  puts "#{row_array1} | #{row_array2}"
end

# --- Ce qui permet de calculer rapidement la distance euclidienne de deux vecteurs
def euclidean_distance(vector1, vector2)
  sum = 0
  vector1.zip(vector2).each do |v1, v2|
    component = (v1 - v2)**2
    sum += component
  end
  Math.sqrt(sum)
end

vector1 = [1,2,3]
vector2 = [3,2,6]
puts euclidean_distance(vector1, vector2)


# --- Permet de réaliser des fenêtres/groupes de données
array1.each_slice(2).each do |row1, row2|
  puts '-'*30
  puts "#{row1}; #{row2}"
end


# --- Même chose mais avec des duplication de données.
array1.each_cons(2).each do |row1, row2|
  puts '-'*30
  puts "#{row1}; #{row2}"
end

Utilisation de Redis avec Ruby

Il y a plusieurs années lorsqu’il était question de faire de la persistance de données au sein d’une architecture logiciel, les développeurs avaient principalement recours aux bases de données SQL. On parlait de SGDB.
Celles-ci apportaient plus de richesse que les fichiers plats, notamment en termes de concurrences, réplications, transactions, etc.
L’approche ACID était au centre de ces stratégies.
Aussi, différents acteurs étaient présents. Ils garantissaient aux utilisateurs des niveaux d’exigences importants particulièrement grâce aux supports techniques (Oracle, SQLServer, etc.). Le marché était très mature et proposait des compétences de haut niveau. Puis des bases de données Open Source, MySQL, Postgresql ont été acceptées au même titre que les solutions propriétaires. Le marché de l’administration s’est peu à peu ouvert aux développeurs, voir aux non informaticiens avec notamment Access.

Depuis maintenant trois ou quatre ans, les bases nommées NoSQL sont arrivées sur un marché relativement fermé aux innovations. En effet, les approches NoSQL sont différentes : les architectures de données notamment sur les aspects que l’on retrouve au sein des « applications sociales » n’imposent pas nécessairement la mise en place de SGDB SQL classique. Certains types de données peuvent être sauvées sous forme de documents ou de graph.
Sur ce point, les puristes diront que c’est un sacrilège de ne pas respecter l’atomicité des données. Mais si les performances peuvent être sauvées, on peut dire que c’est un mal pour un bien.

Je passe sur le phénomène des Big Data qui en soit n’apporte rien de nouveau.
A mon sens, il s’agit clairement d’un recyclage de discours commerciaux pour vendre plus ce qu’on fait depuis longtemps. La volumétrie de données a certes augmentée mais uniquement dans certains secteurs, comme la téléphonie, les média sociaux. Mais ils ont des outils, des techniques et des approches spécifiques en mesure de faire face aux grosses volumétries.
Pour 95% des entreprises qui souhaitent données de l’intelligence à leurs données il n’est pas nécessaire de faire appel aux Big Data.

Puis, il y a aussi les systèmes à base de Clés/Valeurs, notamment Redis que j’affectionne particulièrement depuis de nombreux mois.

Dans un logiciel, les données sont stockées dans des tableaux, matrices, Hash, Set…
Redis repose sur cette une approche qui est vraiment complémentaire. En effet, Redis permet de partager ce type de données entre différents systèmes logiques (comprendre différents logiciels).

Ceci à plusieurs avantages. D’une part les données sont envoyées sur un serveur (redis) en mesure de gérer de façon autonome ses réplications. Donc d’une certaine manière résister aux pannes. Les données sont centralisées sur une architecture n tiers.
D’autre part, les traitements peuvent être répartis sur plusieurs autres machines autonomes et dédiés. Ce qui a pour conséquence de favoriser la scalabilité horizontale. On peut imaginer des machines spécialisées dans des traitements spécifiques en mesure de venir chercher/échanger les données par l’intermédiaire des serveurs Redis. Si le nombre de données augmente, nous n’avons plus qu’à augmenter le nombre de machines.
Initialement Redis est véritablement optimisé pour l’échange de données principalement temporaires et volatiles. Inutile donc de défendre Redis pour gérer des transactions bancaires :)

Dans ce contexte, Redis est souvent utilisé pour gérer les sessions http entre plusieurs serveurs web.

De mon coté, j’utilise Redis pour faire du traitement mathématique/statistiques de données. Notamment en ce qui concerne du data mining et text mining.
Les données initiales sont stockées, soient dans des bases SQL (MySQL ou Postgresql), soient dans des bases NoSQL(mongodb).

Des Workers, c’est à dire des processus autonomes répartis entre plusieurs machines viennent récupérer les données initiales puis appliquent des calculs et stockent les résultats dans une architecture Redis. D’autres Workers, viennent récupérer ces résultats, effectuent leurs traitements puis échangent/sauvent leurs résultats grâce à Rédis.
Ceci permet partager très rapidement des Hash & Sets, ainsi que des fils d’attentes (Queues).

Dès lors, en fonction des enjeux opérationnels, je peux très rapidement répartir la charge de mes workers entre les actions à effectuer.
Certaines machines sont optimisées pour de la communications réseaux, d’autres pour les calculs. Il suffit d’augmenter ou diminuer le nombre de processus par machines pour gérer les performances.

Que propose Redis ?

Comme je l’ai expliqué plus haut, Redis permet de stocker des données sur un serveur et de les partager avec différents clients.

Chaque donnée est associée à une clé qui est une chaine de caractères. Différentes algorithmes permettent de parser et d’indexer ces éléments. Je vous laisse rejoindre Google pour en savoir plus.

Stockage Simple avec des clés de type Strings

Avec Ruby, pour stocker une donnée de ce type j’utilise deux lignes de code. Une pour la connexion, une pour l’affectation.

redis = Redis.new
redis.set 'mykey', 'My value !'

Redis stock ces données en « binary safe ». Ces clés peuvent contenir différents types de données. Des chaines de caractères, des entiers, du json, du binaire, notamment du JPEG, ou des objets sérialisé.
Cependant, la valeur de chaque clé est limitée à 500Mo. Ce qui laisse de la place :)
Il est possible d’utiliser différentes opérations sur chaque clé : affectation (set), lecture (get), incrémentations atomiques (incr, decr…), ajout (append).
Chaque donnée peut aussi être stockée grâce à des namespaces. Un peu comme une url au moyen de séparateurs ( :, /). Ceci permet d’appliquer des patterns de reconnaissance pour l’extraction.

Un autre élément intéressant est qu’il est possible d’attribuer des dates d’expiration aux données (TTL) qui vont mourir toutes seules.

Un peu de code ;)

puts '--- connexion'
redis = Redis.new

puts '--- ajout, identification, récupération, édition, suppression'
redis.set 'mykey', 'my value'
puts redis.type 'mykey'
v = redis.get 'mykey'
puts "mykey = #{v}"
redis.rename 'mykey', 'macle' # use RENAMENX: only if the new key does not exist
puts redis.exists 'mykey'
puts redis.exists 'macle'
redis.del 'macle'
puts redis.exists 'mykey'

puts '--- uitilisation des namespaces'
redis.set 'mylists:mykey1', 'my value 1' # use : or /
redis.set 'mylists:mykey2', 'my value 2'
puts redis.get 'mylists:mykey1'
puts redis.get 'mylists:mykey2'
redis.keys('mylists:*').each do |key|
  puts redis.get key
end

puts '--- plus loin avec les clés de type String'
redis.set 'mykey', 'My value'
redis.append 'mykey', ' is small'
puts redis.get 'mykey'

class MyClass
  attr_accessor :name
  def initialize(name)
    @name = name
  end
end
my_class = MyClass.new('Hello!')
redis.set 'mydump', Marshal.dump(my_class)
mc = Marshal.load redis.get('mydump')
puts mc.name

redis.set 'mykey', 123
redis.incr 'mykey'
redis.incrby 'mykey', 3
puts redis.get 'mykey'
redis.decr 'mykey'
puts redis.get 'mykey'

# utiliser
#   setnx -> set the value of a key, only if the key does not exist
#   strln -> get the length of the value stored in a key

redis.set 'mykey', 'abcdef'
puts redis.getrange 'mykey', 0, 2

redis.set 'mykey', 'abc'
# set the string value of a key and return its old value
puts redis.getset 'mykey', 'zzz'
puts redis.get 'mykey'

redis.set 'key1', 'value1'
redis.set 'key2', 'value2'
redis.set 'key3', 'value3'
# or use:
redis.mset 'key1', 'v1', 'key2', 'v2', 'key3', 'v3'
# use MSETNX: Set multiple keys to multiple values, only if none of the keys exist
redis.mget('key1', 'key2', 'key3').each do |v|
  puts v
end


puts '--- expiration temporelle de données'
redis.set 'mykey', 'my value'
redis.expire 'mykey', 5 # in seconds
8.times do
  v = redis.get 'mykey'
  ttl = redis.ttl 'mykey'
  puts "ttl: #{ttl}"
  v.nil? ? puts("mykey expired !") : puts("mykey = #{v}")
  sleep 1
end
# or use:
#   setex: Set the value and expiration in milliseconds of a key
#
redis.del 'mykey'

puts '--- persistence des données expirées'
redis.set 'mykey', 'my value'
puts "ttl: #{redis.ttl('mykey')}"

redis.expire 'mykey', 3
puts "ttl: #{redis.ttl('mykey')}"
sleep 1
puts "ttl: #{redis.ttl('mykey')}"

redis.persist 'mykey'
puts "ttl: #{redis.ttl('mykey')}"

Les Sets

Les Sets sont des collections d’objets non ordonnés. Pour faire simple, il est possible d’ajouter des lignes de données à un objet Set.
L’avantage est que chaque élément est unique. En exploitant la méthode SADD, il est donc inutile de vérifier si les données existent ou non avant l’insertion.
Clairement les Sets sont utiles pour ranger des listes de données par exemple des liens, résultats, etc.

Redis propose nativement différents opérateurs comme UNION, INTERSECTION, etc. La taille maximum d’un Set est d’un peu plus de 4 milliards d’entrées (4 294 967 295).

Les Listes

Redis propose aussi de socker des listes de données. Celles-ci s’apparente plus à des systèmes de Queue/Stack. C’est à dire des zones de données dans lesquelles on empile et dépile hiérarchiquement des données. On peut utiliser les opérateurs PUSH, POP, etc.
Cette approche est très puissante pour réaliser des systèmes de taches à accomplir au moyen d’ordres partagés entre différents systèmes logiques.
Les listes permettent de créer des modèle de timelines pour des réseaux sociaux : on empile chaque données et on détruit régulièrement les données périmées.
Aussi exemple, le gem reuby Resque utilise ces fonctionnalités PUSH/POP.
La taille maximum d’une liste est d’un peu plus de 4 milliards d’entrées (4 294 967 295).

puts '---- gestion des Lists: queue, stack, etc.'
# push data
puts redis.llen 'mylist'
redis.lpush 'mylist', 'aaa'
puts redis.llen 'mylist'
redis.lpush 'mylist', 'bbb'
puts redis.llen 'mylist'
redis.lpush 'mylist', 'ccc'
puts redis.llen 'mylist'
redis.lpush 'mylist', 'ddd'
puts redis.llen 'mylist'
redis.lpush 'mylist', 'eee'
puts redis.llen 'mylist'
 
# pop data
puts redis.lpop 'mylist'
puts redis.llen 'mylist'
puts redis.rpop 'mylist'
puts redis.llen 'mylist'

Les Hashes

Les hash permettent d’aller plus loin dans la persistance de données en proposant des objets évolués.
Cette approche est très utile, par exemple pour stocker des profils de données ayant plusieurs champs. Par exemple des utilisateurs avec prénom, nom, email, mot de passe, age, etc.
Tous les champs sont stockés dans un Hash User.

puts '--- gestion des Hash'
redis.hset 'myhash', :aaa, 123
redis.hset 'myhash', :bbb, 456
# or hsetnx: Set the value of a hash field, only if the field does not exist
h = {}
h[:aaa] = redis.hget 'myhash', :aaa
h[:bbb] = redis.hget 'myhash', :bbb
puts h[:aaa]
puts h[:bbb]
puts redis.hlen 'myhash'
h2 = redis.hgetall 'myhash'
puts h2['aaa']
puts h2['bbb']
redis.hkeys('myhash').each do |k|
  puts k
end
redis.hvals('myhash').each do |v|
  puts v
end

Les Sorted Sets

Les Sorted Sets sont très similaires aux Sets. Redis permet de les ordonner du stockage de ce type d’objets.
Toutefois, comme tous les algo. de ce type le temps d’accès à ce type d’objet est proportionnel au logarithme du nombre des éléments. En gros, plus y a d’éléments, plus ca rame…
S’il n’est pas nécessaire d’ordonner les données, rien ne sert donc d’exploiter ce type d’objet.

Sql to Mongodb

Il y a quelques jours, je suis tombé sur une carte présentant la logique permettant de passer de SQL à MongoDB, notamment en exploitant MapReduce.

Je trouve qu’elle est bien faite. Par contre, impossible de me souvenir de sa source…

[Edit du 17 mai 2012 – Merci à Crazy :)] La Source est http://nosql.mypopescu.com/post/392418792/translate-sql-to-mongodb-mapreduce

Une histoire d'espaces insécables

En utilisant la command grep, principalement avec un pipe sur la sortie de “ps aux”, il m’est (trop?) souvent arrivé d’avoir une erreur de type:
command not found: grep
Je n’ai jamais vraiment trouvé de réponse précise à ce problème.

Il s’agit en fait d’une histoire d’espace insécable. Les espaces insécables sont des caractères invisibles empéchant le retour à la ligne. Par exemple en HTML, il s’agit de
Ces caractères se déclenchent grâce à une combinaison des touches alt-space.
D’où le problème avec le pipe | lorsque l’on tape trop rapidement sur son clavier.

Pour en savoir plus, il y a l’article de af83: http://dev.af83.com/2012/03/20/les-espaces-insecables-pour-les-codeurs.html

Deux vulnérabilités dans ImageMagick corrigées

Deux vulnérabilités dans ImageMagick viennent d’être corrigées. Cette librairie est très souvent utilisées coté serveur pour redimensionner et convertir des images après un upload. Le menace est dangereuse dans la mesure où elle permet l’exécution de code arbitraire à distance et le déni de service. Les versions affectées sont ImageMagick antérieures à 6.7.5.3.

Clés SSH sur Github

Dans mon précédent billet j’évoquais la faille de sécurité découverte dans Rails.

Dans le même temps, Github informe ses utilisateurs d’une vulnérabilité découverte. Elle aurait permis à un l’attaquant d’accéder aux clés SSH.
Il est donc conseillé de les modifier.

Message de Github: A security vulnerability was recently discovered that made it possible for an attacker to add new SSH keys to arbitrary GitHub user accounts. This would have provided an attacker with clone/pull access to repositories with read permissions, and clone/pull/push access to repositories with write permissions. As of 5:53 PM UTC on Sunday, March 4th the vulnerability no longer exists.

Vulnérabilité dans Ruby on Rails

Le Certa/Anssi, au travers de sa cellule de veille, rapporte deux vulnérabilités dans Ruby On Rails. Les versions 3.0.x, 3.1.x, 3.2.x sont affectées. Elles concernent l’injection de code à distance, principalement au niveau des méthodes SafeBuffer et “select” qui ne sont pas filtrées manuellement. Voici la note.

Read Now de retour

Il y a quelques semaines j’avais testé une petite application nommée Read Now.
Celle-ci permet d’accéder à des données postées sur Read It Later.

Malheureusement, Read Now avait été retirée sans aucune raison de l’AppStore. Depuis quelques heures elle vient d’être remise au téléchargement sous le nom: Read Later.

Quelques tuto videos Ruby

Voici un lien vers quelques vidéos présentant Ruby:
Vidéos Ruby.

De l’utilité des tests unitaires dans la qualité logicielle

Ce billet fait en quelque sorte suite au précédent présentant les techniques d’utilisation de logger. En effet, j’évoquai que, malheureusement, beaucoup (trop ?) de développeurs tracent et debug leurs codes avec une utilisation excessive de « puts », « printf ».

Je pense que lors du développement d’un produit il est très important d’assurer, dès le début, ses travaux au moyen de petits investissements.
Ceci permet de garder un code évolutif et de réduire considérablement la dette technique.

Pour optimiser la correction des futures anomalies il est important de déployer des tests unitaires. Pour faire simple on peut dire que le principe des tests est d’instancier des classes en les considérant comme des boites noires puis en leur injectant des données. Enfin, on regarde en sortie si ces données correspondent à nos attentes.

Cette façon de faire a aussi l’avantage de forcer à développer par « boites ».
C’est à dire qu’il faut user et d’abuser de la POO en réduisant le code et en l’enfermant dans des modules, composants et classes. On obtient généralement des sources très structurées et transpirant de maturité (d’où l’utilisation des design pattern – mais j’y reviendrai).

On rencontre différentes approches de tests : tests unitaires, fonctionnels, d’intégration, de performances, etc. Chacune de ces approches se complètent. Certaines sont très utiles avec Ruby On Rails.

Avec Ruby, il est vraiment très rapide de mettre en place des tests unitaires. Tout est concentré dans le module « test ».
Pour exposer cette simplicité on peut créer un fichier unique contenant l’ensemble des sources. La partie logique et celle dédiées aux tests.
Il est impératif de comprendre que d’ordinaire il faut dissocier le code logique de des tests. En général, on retrouve les tests dans un répertoire de l’application nommé ‘test’.

#encoding: utf-8

# code logique qui va être testé
module MonModule
  
  class MaClasse
    def initialize(a=nil)
      @a = a
    end

    def ma_methode(b, c)
      return b + c
    end

    def ma_seconde_methode(d)
      return @a + d
    end
  end

end

# - - -
# code des tests unitaires
require 'test/unit'

# généralement on prend le Nom de la classe à tester suivi de 'Test'
# cette classe hérite de Testt::Unit::TestCase
class MaClasseTest < Test::Unit::TestCase
  
  # la méthode 'setup' est appelée avant chaque test
  # on peut donc stoker des variables qui seront utilisées lors de tous les tests
  def setup
    @ma_classe = MonModule::MaClasse.new
  end

  # on prend le nom de la méthode à tester précédé de 'test_'
  def test_ma_methode
    r = @ma_classe.ma_methode(2, 3)

    # on test avec des 'asserts': assert_equal, assert_not_nil, assert_raise...
    assert_equal(5, r)
  end

  def test_ma_seconde_methode
    # on instancie la classe qu'on veut tester
    # ainsi que tous les autres composant nécessaires
    ma_classe = MonModule::MaClasse.new(1)
    r = ma_classe.ma_seconde_methode(2)
    assert_equal(3, r)
  end

end

Puts vs Logger en Ruby

Lors de l’apprentissage d’un langage de développement, tout développeur réalise le traditionnel « Hello World !». Le programmeur se centre sur l’utilisation du vocabulaire propre au langage étudié ainsi que sur ses spécifications lui permettant de mettre en place des algorithmes, d’appréhender la conception de classes et autres mécanismes.

Par exemple en C, cette phase permet d’utiliser l’une des méthodes les plus connues: « printf ».

En ruby, on retrouve la méthode « puts ».

Lorsque le développeur réalise ses premiers programmes, toute cette collection de fonctions est utilisée pour sortir de l’information, généralement dans une console.
Malheureusement, ces méthodes servent souvent, peut être par habitude, à débugger et tracer un programme.

Or, en ruby, il existe la classe Logger en mesure de rendre le travail du développeur beaucoup plus simple surtout lorsque son programme est mis en production.

Cette classe permet par exemple d’exploiter les différentes sorties: STDOUT, STERR, notamment par les sorties console avec “./prg > out 2> err”.
L’effort pour employer cette classe est vraiment minime.

Utilisation de Logger

Voici le premier code:

require 'logger'
logger = Logger.new(STDOUT)
logger.level = Logger::WARN

puts 'Début écriture des logs'
logger.info("Info message...")
logger.warn("Warning message...")
logger.error("Error message...")
logger.fatal("Fatal message...")
puts 'Fin écriture des logs'

logger.close

Ce code est très simple: après le chargement du module Logger, on créé l’objet en question avec le paramètre STDOUT. Celui-ci indique que les écritures des logs vont se faire sur la sortie standard (cad la console). Ce qui équivaut à faire un “puts”.

Puis, on affecte un niveau de traitement des logs. Dans notre cas, toutes les logs supérieures ou égales à WARN seront écrites.
Ceci sert principalement lors de la release d’un programme. On affectera ce niveau à Error ou Fatal pour sortir le minimum d’informations qui seraient utiles.

La suite est très simple. Puis on ferme le logger.

L’avantage de cette approche est double. D’une part on peut très facilement maitriser le niveau d’information qui va sortir du programme. Celui-ci ne sera pas le même suivant qu’on l’éxécute de façon classique ou en mode verbose/dev. D’autre part, on peut exploiter le potentiel des sorties STDOUT et STDERR.
En remplaçant STDOUT par STDERR, vous pourrez exécuter le programme avec les traditionnels paramètres “>…” “2>..” “>>..”:
./prog 2> err
Les logs seront exportées vers le fichier “err” alors que tout ce qui concerne la communication avec l’utilisateur sera sur la console.

Utiliser un fichier de logs

logs_file = File.open('./logs', 'a')
logger = Logger.new(logs_file)
#...

Utiliser SQLite3

STDOUT & STDERR sont des LoggerDevice. Ils implémentent deux méthodes: “write(message)” et “close”.
On peut donc aussi très facilement créer une nouvelle classe implémentant ces deux méthodes pour par exemple écrire les données dans une base de données.
Avec une base Sqlite3, ca donnerait ceci, par exemple:

class SQLite3Device
  require 'sqlite3'

  def initialize(filename='./logs.sqlite')
    @conn = SQLite3::Database.new filename
    create_schema_if_necessary
    insert_message("Open logs")
  end

  def write(message)
    insert_message(message.strip)
  end

  def close
    insert_message("Close logs")
    @conn.close
  end

  private
  def insert_message(message)
    @conn.execute "INSERT INTO logs VALUES('#{message}', '#{Time.now}');"
  end
  def create_schema_if_necessary
    @conn.execute "CREATE TABLE IF NOT EXISTS logs (message BLOB, created_at DATETIME);"
  end
end

logger = Logger.new(SQLite3Device.new)
#...

Rotation des logs

Il est très utile de noter que Logger possède des fonctionnalités en mesure d’effectuer des rotation de logs en fonction d’une durée ou d’une taille.
Pour en savoir plus la doc est très bien faite.

Quelques projets utilisant Ruby On Rails

Un billet très court pour parler du top 25 des projets web exploitant Ruby On Rails:
Le top 25 des sites web utilisant Ruby On Rails.

Créer un Gem Ruby en 2 minutes

Construire des Gems Ruby permet de faciliter le partage et la diffusion de codes source. Soit au sein de l’équipe de développement, soit au sein d’un éco-système Open Source. Par exemple: Github.

Malgré les apparances, il est très facile d’organiser son code en conséquence.

Pour expliquer la démarche, j’ai choisi un exemple très simple: on va étendre la class Integer afin d’ajouter une méthode “add” permettant d’ajouter un nombre.

L’architecture du programme

Notre gem va s’appeler “my_lib”. Il faut donc créer un répertoire /my_lib, puis /my_lib/lib. “/lib” contiendra le code de notre programme. Dans notre cas, celui-ci nommé par un fichier /my_lib/lib/my_lib.rb

class Integer
  def add(i)
    self + i
  end
end

Il faut créer le fichier décrivant les spec du gem. C’est à dire: my_lib.gemspec

Gem::Specification.new do |s|
  s.name        = 'my_lib'
  s.version     = '0.0.1'
  s.date        = '2011-12-28'
  s.summary     = "Integer Extend"
  s.description = "The library opens up the Integer class and adds a method "add", which returns an addition"
  s.authors     = ["Sam"]
  s.email       = ["sam@domain.com"]
  s.homepage    = "http://pagedegeek.com"
  s.files       = ["lib/my_lib.rb"]
end

Construire, installer et diffuser le Gem

L’opération de construction du Gem se fait au moyen de la commande suivante:
gem build my_lib.gemspec

L’ensemble des sources du Gem sont concentrées dans le fichier nouvellement créé: my_lib-0.0.1.gem

Il est donc possible de diffuser ce fichier à d’autres dévelppeurs.

Pour installer ce fichier, on peut utiliser la commande: sudo gem install ./my_lib-0.0.1.gem

Pour tester:

require "my_lib"
puts 2.add(1)

Design pattern "Template Method" avec Ruby

Il y a quelques semaines j’avais annoncé que je réaliserai quelques billets sur l’utilisation des desgins pattern avec Ruby :)

Dans ce billet, je vais donc présenter l’utilité d’utiliser le design pattern nommé “Template Method”. Celui-ci a pour but de déléguer et d’encapsuler le code d’un traitement spécifique dans des classes filles.

J’ai pris un exemple très simple: dans le cadre d’un programme, j’ai besoin de sortir plusieurs informations (output) dans différents formats. Dans mon cas, j’ai mis en place en place deux sorties possible: plain text et HTML.

Que ce passerait-il si je devais ajouter une sortie vers un serveur HTTP ou vers une base de données ?

Dans ce cadre, je présente deux démarches: la mauvaise méthode qui n’est pas vraiment maintenable et une méthode plus évoluée appliquant le design pattern Template Method en Ruby.

Mauvaise approche

###### MAUVAIS CODE / NON MAINTENABLE
class Output
  def initialize(format)
    @format = format
  end
  def write(text)
    write_begin
    write_text(text)
    write_end
  end

  def write_begin
    if @format == :html
      puts "<html>"
      puts "<p>#{Time.now.to_s}</p>"
      #...
    elsif @format == :text
      puts "---"
      puts "#{Time.now.to_s}"
      #...
    end
  end
  
  def write_end
    if @format == :html
      puts "</html>"
      #...
    elsif @format == :text
      puts ""
      #...
    end
  end

  def write_text(text)
    if @format == :html
      puts "<p>#{text}</p>"
      #...
    elsif @format == :text
      puts text
      #...
    end
  end
end

Output.new(:html).write("Hello World !")
Output.new(:text).write("Hello World !")

Ce bout de code, qui a le mérite de fonctionner, ne permet pas d’avoir une évolution rapide. Si je dois réaliser une sortie vers une base SQL, je suis obligé de prendre chaque méthode une part une, puis d’ajouter le traitement d’un nouveau format. Cette approche n’est vraiment pas très élégante. Ces modifications risques de provoquer de nombreux bugs.

La bonne approche

La bonne approche consiste à réaliser une classe abstraite ayant quelques méthodes à implémenter. Les classes filles implementeront à leur manière la façon de traiter les sorties.

class Output
  def initialize; end

  def write(text)
    write_begin
    write_text(text)
    write_end
  end

  def write_begin; raise NotImplementedError; end
  def write_end; raise NotImplementedError; end
  def write_text; raise NotImplementedError; end
end

class HtmlOutput < Output
  def write_begin
    puts "<html>"
    puts "<p>#{Time.now.to_s}</p>"
  end
  def write_end
    puts "</html>"
  end
  def write_text(text)
    puts "<p>#{text}</p>"
  end
end

class TextOutput < Output
  def write_begin
    puts "---"
    puts "#{Time.now.to_s}"
  end
  def write_end
    puts ""
  end
  def write_text(text)
    puts "#{text}"
  end
end

# Output.new.output #génère une exception: la classe n'est pas instanciable.
HtmlOutput.new.write("Hello World !")
TextOutput.new.write("Hello World !")

Cette approche a le mérite de déléguer l’ensemble des traitements aux classes filles. Dans le cadre de l’ajout d’un format de sortie il est très facile d’en ajouter un en créant une nouvelle classe fille.

Réflexion sur la qualité des sources et la maintenabilité d’un projet

Cela fait maintenant plusieurs années que je suis amené à auditer du code source.

Le plus souvent, je suis face à un prestataire qui a conçu un outil, généralement un projet web. Celui-ci souhaite résoudre des problématiques d’évolutions techniques et fonctionnelles.

Autant le dire aussi brutalement, je constate malheureusement trop souvent que les sources tendent simplement vers une certaine forme de médiocrité : soit, le code manque cruel d’élégance, soit c’est carrément la conception qui est défaillante. Dans tous les cas les sources sont usées.

Par code source manquant d’élégance, je pense à des fichiers regroupant des centaines de ligne de codes intégrées dans une unique fonction sans aucune notion d’objet. Pour couronner le tout, je retrouve des parties de codes sources totalement en commentaire…

Je pense aussi à ces projets cloisonnés dans une arborescence douteuse et présentant des fichiers renommés à la vite par des underscores et des ‘…version-avant-2010…’.
Vous avez surement vu d’autres exemples ?

Pourquoi écrire du code de qualité ?

Pour moi, le développement logiciel ne se résume à taper de la ligne de code.
Le développement ne se simplifie pas uniquement à des “règles métiers” transpirant les désires du client.

Trop souvent, je découvre de nombreuses fonctionnalités implémentées par de longs discours de façon à s’approcher vaguement des définitions présentées dans le cahier des charges.
On retrouve dans ce type de code des enchainements de conditions, sous-conditions, suivies de particularités écrites sans précision spécifique.
Du sale code…

On se retrouve avec du code plus proche de l’assembleur que de concepts de hauts niveaux.

Les opportunités offertes par les concepts orientés objet sont malheureusement sous-exploitées. Je remarque que les développeurs tombent trop souvent dans les facilités.

Mais n’importe quel non initié répondra que cette approche a le mérite de fonctionner et participe à la réalisation de l’effet final recherché de l’application.

Malheureusement il se trombe. Ce type de développement nuit gravement à la maintenabilité du code et donc à son évolution.

La maintenabilité du code d’un projet est le fondement de sa capacité de réagir aux évolutions futures. Pour moi, cela est l’élément essentiel de l’investissement fait par le client.
Je pense que la qualité doit être une réalité enveloppant le projet dans son ensemble et non une simple option.

Lors des phases de conception ne pas mettre en place une architecture logique reposant sur les bonnes pratiques de conception, notamment l’emploi de design patterns, tend inévitablement vers une certaines forme d’usure du code.

Un code non maintenable réagira difficilement aux évolutions fonctionnelles et aux corrections; ou du moins sans des efforts excessifs.

Si les phases de conception n’ont pas pris en compte ces notions en ne faisant, par exemple, que retranscrire les précisions fonctionnelles, alors il est fort possible que les sources codées par la suite vont générer des incompréhensions et bugs logiciels

Qu’est-ce qu’un code/projet de qualité ?

Techniquement, je pense qu’un code de qualité est un code dont sa maintenabilité est assurée et simplifiée à l’extrême. Tous les concepts: DRY, KISS…, Desing Patterns, sont là pour nous aider.

Un projet maintenable est réactif face aux changements.
La maintenabilité du code, ce n’est pas des règles bêtement apprises, ni des recettes et encore moins des solutions technologiques. La maintenance du code est uniquement une œuvre de réflexion appliquée au moment de la conception.
La qualité d’un code maintenable se mesure sur le long terme.

Chaque développeur doit avoir à l’esprit que l’essence du code est plus facile à présenter grâce à des notions de haut niveau.
Je veux dire par là, qu’il est plus facile de maintenir des objets que de longues fonctions.

Les sources, mais surtout leur conception, doivent dévoiler les différents buts du projet. Au risque de me répéter ceci peut être facilité par l’orienté objet.

Aussi, je pense que le projet ne doit pas être considéré uniquement sur la base de finalités fonctionnelles.
Pour le client, seule cette partie compte vraiment.
Pourtant, le projet est un ensemble d’enchainements, d’écrans et de formulaires. C’est donc au concepteur/développeur de mettre en œuvre les efforts pour accompagner, conseiller et cadrer les demandes, surtout lorsqu’elles sont atypiques.

Encore trop souvent, j’entends des industriels qui répondent face à des demandes exotiques de la part de leurs clients, des propos du genre: “mais Monsieur le client, je fais ce que vous voulez!”. Sans réflexion, on se retrouve avec des usines à gaz fonctionnelles et techniques.

Le rôle du concepteur est aussi d’accompagner le client en proposant des solutions qui vont répondre à la fois aux enjeux fonctionnels mais aussi à la maintenabilité technique du projet. Ceci passe par l’argumentation du refus d’implémenter tous les désires exotiques. Il est souvent nécessaire de recadrer ce type de demandes.

Comment coder avec qualité et élégance

Il existe plusieurs moyens permettant de mettre en place une logique de qualité.

Concernant l’édition du code, il est nécessaire d’avoir des règles précises et partagées par tous. Je pense principalement aux conventions de nommages des variables, class, etc. Mais aussi aux règles d’encodage, de tabulations, etc.
Il peut être nécessaire de mettre en place des doctrines du type : Do not Repeat Yourself & KISS (Keep It Simple, Stupid). Cette dernière préconise de rechercher la simplicité dans la conception et l’architecture logique. Dans ce cadre, ne pas hésiter à rassembler des fonctions au sein d’objets de type “Façade” ou autre.
Coder des fonctionnalités indépendantes du projet dans des plugins (des gems pour Ruby par exemple).
Ne pas mélanger les codes MVC. Ne pas faire du contrôle de données dans les vues. Les contrôleurs ne gèrent pas la validation des données non plus ; ni leur présentation. En général une fonction se compose de 5 à 15 lignes max. de lignes. Une fonction ne fait qu’une et unique chose.
Maintenir les évolutions du projet au sein d’un Système de Gestion de Version. Au pif: GIT !
Avoir des espaces de développement, test, pré-prod, prod. et ne pas faire de modifications en prod. User de patch.
Mettre en place des tests unitaires.
Refactoriser le code de mauvaise qualité. Consolider l’existant. Dans cette phase, le but recherché n’est pas de développer de nouvelles fonctionnalités mais de les implémenter de façon élégante et rationnelle.
Supprimer le code mort. Dans la vie du projet, il existe obligatoirement des parties du code qui sont inutilisée. Autant les supprimer maintenant.
Mettre en évidence les problèmes de conception et ne pas hésiter à reforger la conception de l’application.
Prendre en considération que le code « s’use » !

Pagination à la Facebook avec Ruby On Rails

J’avais envie de présenter très rapidement comment mettre en place un système de pagination très simple à la Facebook. C’est à dire que le contenu ne se charge plus par page mais par date de création grâce à AJAX.

Le Controller

On va commencer par le controller en exploitant la fonction respond_with() de rails 3 permettant de générer les données en fonction du type souhaité (HTML, JSON, XML, etc.).
Bien entendu, ce code peut être optimisé avec des scopes, mais je n’avais pas envie de surcharger cet article.

respond_to :html, :json
def index
  limit = 2
  if params[:last].present?
    @posts = Post.order("created_at DESC").where("created_at < ?", params[:last]).limit(limit)
  else
    @posts = Post.order("created_at DESC").limit(limit)
  end

  respond_with(@posts)
end

La Vue

<h1>Listing posts</h1>
<ul id="posts" data-last="<%= @posts.last.created_at %>">
<% @posts.each do |post| %>
  <li><%= post.body %></li>
<% end %>
</ul>
<a href="javascript:void(0)" class="load_posts">Next</a>

Le javascript

$(function(){
  $('.load_posts').click(function(){
    $.getJSON("/posts.json?last=" + $('#posts').attr('data-last'), function(data){
      $.each(data, function(k,v){
        $('#posts').append("<li>" + v.body + "</li>");
        $('#posts').attr('data-last', v.created_at);
      });
    });
  });
});

Un initializer pour gérer l’affichage de la date avec JSON

Par defaut avec json, la conversation d’une date en chaine de caractère n’est pas vraiement optimale. Il est donc nécessaire de créer un initializer par exemple config/initializers/times_format_json.rb

class ActiveSupport::TimeWithZone
  def as_json(options={})
    strftime('%Y-%m-%d %H:%M:%S UTC')
  end
end

Voilà !

Livres bonnes pratiques programmation orienté objet

J’ai rencontré beaucoup de développeurs sachant programmer, ou du moins se servir d’un langage de programmation. Ces développeurs sont souvent autodidactes sur des technologies particulières.
Je pense qu’il n’y a rien de mal à ca. Au contraire, il est important de suivre les évolutions techniques.

Toutefois, la conception d’ensemble d’une application ne se résume pas à taper de la ligne de code et à appliquer à la lettre les recommandations d’une documentation.

Je pense que peu de personnes savent bien concevoir l’architecture logique d’une application. Par architecture logique, j’entends l’implémentation des concepts métiers de haut niveau.
De la même manière que la programmation, la conception d’application s’apprend aussi en étudiant ce qui a déjà été fait.
J’ai donc retenu quelques livres utiles à ceux et celles qui veulent se perfectionner dans cet art.

Object Oriented Analysis Design Applications
Object Oriented Software

Plugins VIM essentiels avec Ruby & Rails

Je le présentais dernièrement dans un billet, j’ai quitté TextMate pour passer à VIM. TextMate a gagné la confiance des développeurs grâce à sa capacité de configuration et à ses nombreux raccourcis clavier très productifs. Beaucoup de développeurs, principalement issus du web, ont fait le choix d’exploiter un éditeur de code évolué plutôt d’un IDE. Notamment pour pallier à leur lourdeur. Je pense que cette tendance s’est développée grâce aux capacités avancées de personnalisation des éditeurs de code. Par exemple, ils proposent des systèmes de “Snippet” qui sont très productives. Celles-ci permettent de générer des parties de code source “à la volée”. Je ne parle pas de génération automatique de codes. Simplement la possibilité de générer et d’automatiser la production de quelques lignes de code souvent répétitives. Ce système permet, à mon sens, une plus grande maitrise des sources.

Snippet

Vim propose par defaut un système équivalent aux Snippets. Ce sont les “abbreviations”. Par exemple, en saisissant la ligne suivante dans votre .vimrc:

  abbr psvm public static void main(String[] args){<CR>}<esc>0

vous pourrez, en tapant psvm puis TAB, générer la ligne de code très connue en C: public(…).

Toutefois, j’ai trouvé le plugin SnipMate plus intéressant: Télécharger SnipMate VIM. Celui-ci se compose par default de différentes snippets situées dans .vim/snippets/*. La documentation est très bien faite. Je ne vais donc pas rentrer dans les détails. Il faut juste noter que les snippets liées à HTML & Ruby sont très productives.

NOTE: Sous MacVim il existe un petit problème: lorsque l’on sélectionne du texte, une pression sur backspace fait revenir le curseur au delà de la position classique.
Pour corriguer ce problème, il suffit de commenter la ligne “snor b” située dans le fichier .vim/after/plugin/snipMate.vim.

Auto Close

Par defaut, VIM ne propose pas la fermeture des symboles: [], (), {}. J’ai comblé cette lacune avec le plug-in “autoclose” disponible à cette adresse: https://github.com/Townk/vim-autoclose.

Ouverture des fichiers

NERDTree permet d’ouvir un arbre présentant les fichiers du dossier courant. L’ouverture de cet arbre peut être mappé. Ainsi en mode visualisation, en tapant F12, l’arbre s’affiche ou non. Voici mon .vimrc paramétrant ces éléments:

map <F12> :NERDTreeToggle<CR>
"let g:NERDTreeWinPos = "right"
let g:NERDTreeWinSize=33

Sous TextMate la touche Cmd-T facilite l’ouverture d’un fichier recherché. Le plugin-in FuzzyFinder permet de mettre en place cette fonctionnalité de la même manière. Notamment la commande “:FufCoverageFile”. J’ai mappé celle-ci avec la touche F11, ce qui donne dans mon .vimrc:

map <F11> :FufCoverageFile<CR>

Lorsqu’un fichier est selectionné, on peut utiliser différentes combinaisons pour l’ouvrir:
- Enter pour ouvrir dans la fenêtre courante
- CTRL+j pour ouvrir avec un split
- CTRL+k pour ouvrir avec un vsplit
- CTRL+k pour ouvrir dans une tab

Editer du code eRuby

Sous Textmate, il est possible de créer automatiquement le code suivant: “<%= %>” au moyen du raccourcis SHIFT+CTRL+>. Le plugin RagTag permet de réaliser ceci sous VIM au moyen des touches CTRL+W puis = ou SHIFT+=.

De la couleur

Il existe aussi le thème RailsCasts disponible: RailsCasts adapté à VIM. Toutefois, j’ai préféré utiliser mon propre thème: ParisByNight adapté à Ruby On Rails.

Alternatives à Yahoo Explorer

Yahoo Explorer vient de fermer ses portes. Dommage, cet outil était vraiment très pratique pour avoir une vision assez globale des backlinks pointant vers une page spécifique.
Ceci est intéressant en SEO pour en savoir plus sur un domaine particulier (le sien ou dans un environnement concurentiel par exemple).
Il existe pas mal d’outils en mesure d’apporter ce type de connaissance. Malheureusement, ils n’ont pas l’avantage de posséder l’index de Yahoo.
Je vous propose donc une petite liste d’autres outils alternatifs à Yahoo Explorer. Il est important de noter ces outils en ligne n’ont pas la puissance de yahoo car ils ne “crawlent” malheureusement qu’une petite partie du web.

http://www.opensiteexplorer.org/
http://www.analyzebacklinks.com/
http://www.bing.com/search?q=URL-SITE&go=&qs=bs&form=QBRE
http://www.google.fr/search?q=link:URL-SITE
http://www.alexa.com/site/linksin/URL-SITE
http://www.exalead.fr/search/web/results/?q=link:URL-SITE
https://www.majesticseo.com
http://www.seoheap.com/backlink-checker/URL-SITE
http://www.backlink-tracker.net/reports/URL-SITE

Vulnérabilité dans Ruby On Rails

Ruby On Rails comporte une vulnérabilité permettant l’injection de code à distance.
Celle-ci concerne les version 3.0.0 et supérieures, ainsi que les 2.3.x utilisant le module rails_xss.

La vulnérabilité est présente dans la fonction “translate” de Ruby On Rails

Sources

Déployer plusieurs applications Rails 3 sur un serveur Apache 2.2 avec Phusion Passenger

Tout d’abord j’ai préféré déployer httpd en local en recompilant les sources.
Ceci afin d’être relativement autonome dans la gestion des dépendances et des modules.

La procédure d’installation à suivre est classique:

tar zxvf httpd-2.2.21
cd httpd-2.2.21
./configure --prefix=/Applications/httpd/2.2.21 --enable-so
make
sudo make install
unlink /Applications/httpd/current
ln -s /Applications/httpd/2.2.21 /Applications/httpd/current

On peut tester si httpd se lance bien en suivant cette procédure:

cd /Applications/httpd/current/bin
sudo ./apachectl start

Déployer Phusion Passenger

On commence par installer le gem avec la commande suivante:

sudo gem install passenger

Puis on lance l’opéation de déploiement sur httpd:

passenger-install-apache2-module --apxs2-path=/Applications/httpd/current/bin/apxs

L’installateur nous demande d’ajouter les lignes suivantes dans le httpd.conf:

LoadModule passenger_module /Applications/ruby/1.9.3-p0/lib/ruby/gems/1.9.1/gems/passenger-3.0.9/ext/apache2/mod_passenger.so
PassengerRoot /Applications/ruby/1.9.3-p0/lib/ruby/gems/1.9.1/gems/passenger-3.0.9
PassengerRuby /Applications/ruby/1.9.3-p0/bin/ruby

Puis se clôture en proposant une configuration pour une application rails.
Celle-ci est assez simple. Je vous propose plutôt la mienne qui permet d’exploiter plusieurs applications rails sur un même serveur httpd.
Cette configuration est utile dans le cadre d’applications locales ou sur un serveur de test, voir de petites applications en prod.

Dans mon contexte, j’ai créé un répertoire railsapp à la racine de httpd: /Applications/httpd/2.2.21/railsapp/

En production, de même que le fichier htdocs, il est recommandé de mettre les applications dans /var ou /opt et d’adapter les droits en conséquence.

On commence par créer un lien symbolique dans le htdoc d’apache httpd:

ln -s /Applications/httpd/2.2.21/railsapp/HelloApp/public/ /Applications/httpd/2.2.21/htdocs/hello

Il faut bien faire pointer le répertoire “public” de l’application.

Puis on créé un Virtualhost dans le httpd.conf:

<VirtualHost *:80>
	DocumentRoot /Applications/httpd/current/htdocs/
	<Directory /Applications/httpd/current/htdocs/>
		#Order allow,deny
		Allow from all
  </Directory>
	
	RailsBaseURI /hello
	RailsEnv production
	
	<Directory /Applications/httpd/current/htdocs/>
		Options -MultiViews
	</Directory>
</VirtualHost>

RailsBaseURI /hello doit correspondre au lien symbolique que l’on a créé dans le htdocs. Attention donc à la casse.
Il est possible de créer d’autres application en créant simplement d’autres liens symboliques et les en faisant pointer sur d’autres RailsBaseURI /.

Avant une mise en production d’une application Rails 3, il est nécessaire de pré-compiler les assets en éxécutant la commande suivante:

bundle exec rake assets:precompile

Aussi, il ne faut pas oublier de monter votre base de données de production avec:

rake db:create RAILS_ENV=production
rake db:migrate RAILS_ENV=production

Voilà!

Raccourcis SSH

Lorsque l’on gère quelques serveurs SSH, notamment pour ses clients ou ses propres besoins, il est fastidieux de devoir taper à la main à chaque fois l’url ou l’IP des serveurs.

Avec SSH, il est possible de créer des raccourcis. Il suffit de créer le fichier de configuration suivant:
# vi ~/.ssh/config
puis de saisir quelques lignes de configuration.

host srv1
  hostname 0.0.0.0
  user developer

host srv2
  hostname 0.0.0.0
  user root

srvX correspond au nom que l’on veut donner au raccourcis. On utilisera directement dans un terminal la commande suivante:
# ssh srvX
0.0.0.0 est l’IP de la machine. On trouve ensuite le nom d’utilisateur de connexion SSH.

Une extension en C pour Ruby

Il y a quelques jours j’ai eu besoin d’étendre Ruby en réalisant une extension en C. En effet, mon algo. comportait des calculs mathématiques déjà optimisés en C. J’ai donc préféré la transformer en librairie et l’exploiter avec Ruby.

Pour réaliser une extension C en Ruby, c’est très simple. Pour commencer, il faut le fichier monextension.c et test_monextension.rb. Le premier fichier correspond au code source. Le second ficher afin d’exploiter l’extension.

require './monextension'

include MonExtension
puts ma_methode

#include <ruby.h>

VALUE MonExtension = Qnil;

void Init_mytest();

VALUE method_ma_methode(VALUE self);

void Init_monextension() {
	MonExtension = rb_define_module("MonExtension");
	rb_define_method(MonExtension, "ma_methode", method_ma_methode, 0);
}

VALUE method_ma_methode(VALUE self) {
	int x = 10;
	return INT2NUM(x);
}

Pour compiler la librairie, il est possible de générer automatique un make file. Pour se faire, il faut créer le fichier extconf.rb

require 'mkmf'

ext_name = 'monextension'

dir_config(ext_name)
create_makefile(ext_name)

En l’exécutant avec un ruby extconf.rb, vous générerez automatique le makefile

Pour compiler l’extension, rien de bien compliqué. Vous tapez un “make” dans le terminal afin de compiler la librairie.

Gestion d'un projet innovant

Cette note s’adresse avant tout aux entrepreneurs et aux personnes souhaitant mettre en place un projet innovant. Le web regorge de ressources pour décrire un business plan, choisir une architecture technique, etc. Mais, je n’ai pas vraiment trouvé d’informations concernant la gestion de projets innovant, requérant implicitement des efforts de créativité.

Il y a plusieurs mois j’ai été amené à diriger un projet qui n’était pas vraiment conventionnel. Il s’agissait d’un projet d’innovation. Ce type de démarche est problématique dans le sens où la créativité doit émerger d’une équipe et non d’une seule personne.

Depuis quelques années, je pense que le terme innovant est malheureusement reprit à toutes les sauces. Dès qu’un discourt est diffusé afin de présenter un produit, le terme innovant est rapidement associé. Souvent à tord.
Je pense que beaucoup d’individus confondent nouveauté et innovation. Créer un projet innovant ne se résume pas à créer un projet nouveau.

Diriger un projet, notamment lorsqu’il s’agit d’un projet web, est un processus globalement maitrisé. On réalise des briefings client. Puis un cadrage fonctionnel est effectué au moyen d’un cahier des charges. On peut mettre en place différentes approches de construction (livraison par lots, en mode agile, etc.).
Lorsque le porteur de projet sait globalement ce qu’il veut, là où il veut aller sur le plan fonctionnel, il se repose sur la MOE pour retranscrire ses attentes dans une dimension technique afin de bâtir son projet.
Bien sûr, il peut y avoir quelques éléments perturbants, des aléas, des incompréhensions. Mais celles-ci font parties intégrantes de la vie du projet.

Qu’en est-il d’un projet innovant ?

Par innovant j’entends un projet dont l’issue finale est incertaine, indéfinie. Tant sur le plan fonctionnel, organisationnel que technique. Un projet dont l’effet final recherché (EFR) n’est pas et ne peut être défini avec précision.
Il s’agit d’une situation où les porteurs de projet ont une idée générale décrivant une carence qu’ils ont identifiée et souhaitent la combler. Ils souhaitent apporter leur brique à l’édifice sans trop connaitre celui-ci.

Dès lors, quelles ressources mettre en place pour atteindre une étape opérationnelle ? Les méthodes de conduite de projet classiques fonctionnent-elles dans cet environnement ? Peut on se contenter de briefs, de cahiers des charges clairement établis ? Doit-on justifier d’une approche agile ? Comment évoluer entre ordre et chaos créatif ? Comment gérer la créativité et le facteur humain dans ce contexte ?

Mon expérience ma montré que ce type de projet nécessite de gros efforts. Je ne parle pas uniquement d’efforts financiers.
A ce stade, il est malheureusement classique pour un porteur de projet de tomber dans les facilités faisant intervenir uniquement les enjeux techniques. Il est courant de tout faire reposer sur la technicité du projet.
J’ai remarqué que les environnements inconnus sont en général considérés par les profanes comme étant capable de répondre à tous les problèmes du projet. La faute peut être aux discours magiques de commerciaux peu scrupuleux; ou peut être au manque de curiosité des équipes se contentant de phrases toutes faites.

A ce titre, je me souviens d’avoir entendu que le manque de curiosité était un défaut professionnel. Qu’en pensez-vous ?

Dans ce contexte, il est très facile d’amalgamer des systèmes à des boites noires. Le porteur de projet part du principe que des sortes alchimistes connaissent les méandres de systèmes et sont en mesure, par l’intermédiaire d’une technologie ésotérique de transformer n’importe quel plomb en or.
Pour le client, toutes les problématiques auront des solutions, sans aucune limite, sans prendre en considération les contraintes, sans concession nécessaires. (De toute façon le client est roi, dit-on ?).

On peut aussi rencontrer le porteur de projet qui souhaite « challenger » des développeurs comme il le ferait avec ses commerciaux. Or, il ne fait que confirmer son incapacité à ne pas comprendre que les défis techniques ne sont pas en mesure de répondre à des sollicitations par le stress. De plus, il ne prend pas en compte la démotivation des développeurs qui est pourtant une réalité bien réelle. Est-il nécessaire de rappeler qu’un bon développeur démotivé partira. Dans ce contexte, qu’en sera-t-il de la perte connaissance du projet ?

Ces considérations sont malheureusement des erreurs et portes inévitablement le projet innovant vers l’échec.

Au stade d’innovation, seul compte le facteur humain!
L’accompagnement projet est fondamental. Il faut arriver à repositionner l’Homme et surtout sa créativité au centre du projet. Le principal défi est la mise en place d’outils permettant de canaliser la créativité issue de l’équipe projet. Il faut impérativement esquiver les caprices du client roi. C’est de toute façon pour son bien.

Définissons quelques points

Tout d’abord, le projet étant de nature innovante son objectif final n’est pas défini avec précision. Il peut évoluer en fonction du temps et des informations en présence.
Il faut donc se concentrer sur ce qui est important au projet.
Le porteur du projet vous répondra par des enjeux fonctionnels, des réalités économiques et des finalités techniques. Mais avant tous ces éléments, comme j’ai essayé de le décrire plus haut, la motivation des membres projet est un élément critique : sans personnels, pas de créativité, pas de projet. La motivation étant source de créativité. S’il y a bien un élément qui ne peut s’acheter et se maitriser, c’est bien la capacité créative. Vous pourrez recruter des personnes qui ont été créatives dans le passé ; rien n’affirme qu’elles le seront sur votre projet.
On peut donc s’attarder à identifie au plus tôt ce qui anime les membres du projet, par exemple en exploitant la pyramide de Maslow.
J’ai envi de reprendre la citation d’Antoine de Saint Exupéry qui résume bien la situation (j’en prendrai d’ailleurs d’autres) : « Si tu veux construire un bateau, ne rassemble pas tes hommes et femmes pour leur donner des ordres, pour expliquer chaque détail, pour leur dire où trouver chaque chose… Si tu veux construire un navire, fais naître dans le cœur de tes hommes et femmes le désir de la mer. »

Rester face à la réalité.

Il vaut mieux refuser des fonctionnalités trop couteuses en temps ou trop compliquées à ce stade du projet innovant.
Mettre la pression sur des éléments intenables ou des délais trop court est un risque à ne pas prendre. Cela rassurera tout au plus le cient roi, dictateur qui retrouvera ses repères.
Ce genre de situation a pour conséquences de créer de fausses attentes, de générer du stress inutile et de fournir une vision altérer des échéances.
Il faut aussi se rappeler qu’une personne malgré son expérience est très mauvaise pour prévoir.
J’aime beaucoup ce que dit Antoine de Saint Exupéry dans Terre des Hommes à propos de l’évolution de l’aviation : « Dans quelque domaine que ce soit, la perfection est enfin atteinte non pas lorsqu’il n’y a plus rien à ajouter mais lorsqu’il n’y a plus rien à enlever » Antoine de Saint-Exupéry

Communiquer !

Il ne faut pas uniquement communiquer pour rassurer le client ou prendre ses directives d’une chaine hiérarchique. Il faut qu’il y ait un échange d’informations à battons rompus sans distinction de système hiérarchique. Il éviter certaines personnes avides de reconnaissances qui monopoliseront sans état d’âmes les débats et orienteront les échanges dans de mauvaises directions.
De la même manière, il faut éviter que les personnels hiérarchiques exploitent leur position afin de se rassurer sur leurs capacités managériales.

Elles doivent plutôt se concentrer sur la capacité à faire émerger chez les personnels des éléments de créativité.

La communication doit être régulière. Idéalement, les membres projet devraient se parler physiquement tous les jours. Leur rôle est de faciliter cette cohésion.
Si les membres projet sont nombreux, qu’il y a des difficultés de planning pour se réunir, on peut mettre en place des binômes temporaires qui travaillerons sur une semaine ensemble. La semaine suivante après un Retex, on change les binômes. Les idées évoluerons d’elles mêmes.

Ecouter !

L’écoute au sein d’une réunion créative est très importante, même si ce qui est dit est sans intérêt pour le projet. En coupant un échange ou en cadrant immédiatement un personnel, il se peut qu’elle ressente une frustration à ne pas pouvoir s’exprime par la suite.
Dans le futur, rien ne permet d’affirmer que cette personne pourrait apporter une solution à une nouvelle problématique. Si elle a été frustrée, il se peut qu’elle s’enferme dans son silence. Il faut se forcer à différer le jugement.
Toutefois, cette approche est un jeu difficile lorsqu’il s’agit de cadrer un caprice d’un manager.

Dans le contexte d’un projet innovant, face à une problématique tout le monde peut avoir une solution à proposer. Tout le monde peut proposer sa vérité et ses raisons. Il est très difficile d’avoir raison, d’émettre une vérité absolue par exemple en décrivant une fonctionnalité.
Il faut faire comprendre que tous les personnels peuvent avoir raison, tout le monde peut se tromper, tout le monde peut changer d’avis. Il est absolument nécessaire de mettre en place une situation où l’intuition de l’un ne pèse pas plus que l’intelligence de l’autre, que l’expérience de l’un n’équivaut pas plus que l’intuition de l’autre et l‘expérience n’évince pas le fantasme d’un autre.
A ce stade d’un projet d’innovation, il faut éviter les dictatures autoritaires et les décisions figées.
Si certaines propositions sont trop abstraites, on peut utiliser des paper board pour communiquer. Les autres membres projet pourront « écouter » avec plus de facilité.

Les réunions doivent avoir un centre d’équilibre entre chaos créatif et ordre éclairant. Il faut équilibrer le respect des idées des autres et ses idées. La créativité doit être partagée avec chaque équipier.
Ces réunions doivent absolument se clôturer sur des idées optimistes. Ces éléments doivent être source de joie. Chaque membre projet doit désirer que quelque chose naisse et émerge de cette réunion. Il faut rester dans le champ des possibles. Le rôle du manager est de transpirer cette joie et de la rendre contagieuse.

Ces réunions créatives sont de véritables processus de recherche d’idée en équipe. Résoudre des problèmes, créer doit être source d’amusement. Même si les personnels sont payés des fortunes, ils doivent s’amuser. Ce n’est pas se contenter d’appliquer des normes et des modèles existants pour solutionner une problématique.

Pour finir

Je vous propose de considérer que le projet innovant ne doit pas avoir de fin. Il doit être dans une situation de perfectionnement constant. Au même titre que les hommes et femmes qui le bâtisse et se perfectionnent avec lui.
S’il y a bien un avantage avec les projets web, c’est qu’il est facile de les considérer de cette façon.

« …seuls vivent ceux qui n’ont point trouvé leur paix dans les provisions qu’ils avaient faites… » – Antoine de Saint Exupéry

Thème Textmate ParisByNight

Juste une petite note pour partager simplement le thème Textmate que j’ai réalisé (lorsque je ne me sers pas de Vim ).
Paris By Night

Le design pattern Singleton avec Ruby

Il y a quelques années lorsque je développais quotidiennement en Java, j’exploitais beaucoup les Design Pattern: Facade, Factory, Singleton, DAO, etc. Les Design Pattern, quelque soit le langage utilisé, permettent de répondre à des problématiques logiques par des solutions connues de tous.

L’arrivée des frameworks comme Ruby On Rails a mis en évidence ce genre de pratiques au sein de travaux web. On utilise régulièrement Model View Controller, DAO, etc. Je vais donc essayer de faire plusieurs articles sur l’utilisation des design pattern en ruby pour la conception web puis d’expliquer leurs fondements et leur utilité.

Singleton en Ruby

L’objectif de Singleton est d’instancier une seule fois une classe dans le déroulement du programme. Lorsque l’on appel la procédure getInstance (ou instance) on récupère l’objet unique.
En Ruby, l’utilisation de Singleton est facilité. Je propose donc un exemple simple pour présenter l’utilisation du design pattern Singleton en Ruby.

#encoding: utf-8
require 'singleton'

class MyClass
  attr_accessor :data
  include Singleton
end

a = MyClass.instance #on instancie pour la première fois, l'objet va donc être créé en mémoire
b = MyClass.instance #on récupère l'instance, sans savoir sans avoir besoin de savoir si l'objet a déjà été créé en mémoire

a.data=123
puts b.data # b.data possède la même valeur que a.data car c'est la même instance

Un autre exemple plus pragmatique d’utilisation de Singleton pour gérer les log d’un programme.

#Encoding: utf-8
require 'singleton'

class AppLogger
  include Singleton
  
  attr_accessor :level
  
  ERROR=1
  WARNING=2
  INFO=3
  
  def initialize
    @log = File.open("app.log", "w")
    @level = WARNING
  end
  
  def error(m)
    @log.puts(m)
    @log.flush
  end
  
  def warning(m)
    @log.puts(m) if @level >= WARNING
    @log.flush
  end
  
  def info(m)
    @log.puts(m) if @level >= INFO
    @log.flush
  end
  
end

logger = AppLogger.instance
logger.level = AppLogger::INFO

logger.info("la procédure a bien été exécutée")
logger.error("Plantage...")

iTerm 2

Lorsque l’on développe sous Mac et plus généralement sous système UNIX, il faut admettre que le terminal fait parti du quotidien. Mac OS X Lion a apporté son lot de nouvelles fonctionnalités. Notamment un gestion approfondie des onglets et d’autres détails esthétiques comme la transparence et le blur.

Je me serais probablement contenté du terminal par défaut si je n’utilisais pas les fonctionnalités de split de Vim très utiles lorsque l’on code avec Ruby On Rails.

J’ai découvert il y quelques semaines iTerm2. Ce terminal ajoute certaines fonctionnalités dont une très intéressante: le split vertical. Cette fonctionnalité est extrêmement utile lorsque que l’on travail avec une connexion SSH pour une opération de maintenant ou pour afficher les logs d’un serveur web ruby par exemple.

Toutefois, cette version d’iTerm2 possède quelques problèmes. Il est par exemple nécessaire de mapper certaines touches sur les claviers francophones. Je pense notamment au ALT+Fleches pour déplacer le curseur de mot en mot.
Pour ce faire, il suffit de suivre les éléments de la capture ci-dessous afin de résoudre ce problème et mapper le bon raccourcis clavier.

“b”, pour revenir sur le mot précédent. “f”, pour pousser le curseur au mot suivant.

Synchroniser ses données avec rsync

Les systèmes de cloud ont permis l’émergence des sauvegardes projetées sur des serveurs distants. Les particuliers utilisent souvent des systèmes comme Dropbox, Box.net.

Mais lorsque l’on possède un serveur dédié, comme un Kimsufi, il est plus pertinent de synchroniser ses données sur celui-ci.
Cette opération est facilité par l’utilitaire RSync.

RSync

Au dela de projeter les données sur un serveur distant, RSync a la particularité de réaliser des sauvegardes incrémentales. C’est à dire que seules les nouvelles données et les celles modifiées sont envoyées sur le serveur.
Ceci a pour intérêt de limiter la consommation de bande passante et surtout le temps de ce type d’opération.
J’utilise la commande suivante:

rsync -auv --del --stats ~/mon_repertoire_a_sauver user@serveur.com:~/backup/

L’option a (archiver) permet de conserver les paramètres des fichiers (droits, propriétaire, lien symbolique, etc.).
v (verbose) affiche les traces.
u (update) ne copie pas les fichiers qui n’ont pas changé.
-del, supprime les fichiers sur le serveur qui ne sont plus présents dans le répertoire d’origine. Ne pas hésiter à supprimer cette option pour concerver tous les fichiers sur le serveur.
—stats, affiche des statistiques en fin d’opération.

Retour aux sources de textmate à VIM

De Textmate à VIM

Certains le savent, il y a quelques mois j’ai quitté le monde de Textmate pour un retour aux fondamentaux: le monde de VIM !

Durant une grande partie de mes études j’ai passé mon ordinateur portable sous linux. Sur une promo. de 300 élèves nous devions être moins de 3 étudiants à utiliser linux au quotidien. C’était une Fedora 2 ! Depuis, les temps ont changés, je vois régulièrement des jeunes très à l’aise sous linux. Ubuntu doit être pour quelque chose.

Cependant, en 2005, je suis rapidement passé sous Mac.
Pas par effet de mode, non, juste par nécessité d’avoir Photoshop nativement sous la main. Lorsque l’on est concepteur Web, ce petit programme peut aider :)

Sous Mac, j’ai très rapidement été séduit par Textemate. D’abord par sa légèreté, sa sobriété mais principalement par toutes ses commandes ésotériques, fermées aux profanes mais tellement productives.

Depuis quelques mois, pour des raisons professionnelles j’exploite un poste sous Linux. L’environnement de développement que j’ai mis en place tourne donc autour de VIM.
VIM est aussi un de ces outils mystique tellement productif.

Sous Mac, j’ai découvert MacVIM qui permet d’avoir l’intégralité des commandes VIM compatibles Mac.
Je vais donc réaliser quelques billets de présentation de cet utilitaire. En attendant, je vous propose mon .vimrc.

set background=dark
colorscheme vydark "une thème dark

set guioptions-=T "toggle toolbar for MacVim
set guioptions-=L "toggle left scroll bar
set guioptions-=r "toggle right scroll bar

set lines=53 columns=90 "desfault size for MacVim

map <F2> :NERDTreeToggle<CR>
let g:NERDTreeWinPos = "right"

map <C-S-Right> :set columns=160<CR> "Permet d'agrandir la fenêtre rapidement avec Shift+Fleche droite
map <C-S-Left> :set columns=90<CR>

imap <S-enter> <Esc>$a;<CR> "En faisant un Shift+Enter, le curseur est automatique placé en fin de ligne et un ; est placé. Utile en C, C++, Java...

set showmode "affiche le mode I,V, etc.

set guifont=Bitstream\ vera\ sans\ mono:h11

set encoding=utf-8

set wildmenu "menu lors de l'utilisation de la touche tab

set t_Co=256
set syntax=on
set number
set ruler
set tabstop=2 softtabstop=2 shiftwidth=2 expandtab
set smartindent
set ai
set cursorline
set showmatch
set incsearch
set nobackup 
set nowrap

set autowrite       " Automatically save before commands like :next and :make

set iskeyword+=_,$,@,%,#,-

set gcr=a:blinkon0 "retire le clignotement du curseur

Tweets overload et classification automatique

Tweets Overload et application des SVM

Sur twitter dès qu’on follow un nombre important de twittos on fait rapidement face à une sur-information. Il y a plusieurs mois, j’ai partagé ma petite application: Timeline4lazy. Celle-ci permet à ses utilisateurs d’avoir une visualisation globale de leur timeline twitter. Timeline4lazy analyse en quasi temps réel, les liens partagés sur sa timeline, les hashtags, les mentions et d’autres informations plus ou moins pertinentes suivant l’utilisation que l’on en fait.

Dans l’ensemble, je suis satisfait de cette démarche. Elle reste pertinente. Toutefois, je souhaitais aller plus loin.
En effet, sur Twitter tous les tweets ne sont pas forcément tous intéressant. Je suis donc parti du principe que je pouvais mettre en place un système en mesure de catégoriser automatiquement les tweets de sa timeline en fonction de ses intérêts.
D’où l’introduction suivante à propos des Machines à Support Vecteur.

Les Séparateurs à Vaste Marge

Je pense que tous les lecteurs de ce blog ne sont pas tous des fans de math. Pour résumer, les Séparateurs à Vaste Marge, aussi appelés Machines à Vecteurs Support (Support Vector Machine) sont des algorithmes supervisées développées par Vladimir Vapnik chez AT&T Bells labs dans les années 90. Ces algorithmes sont principalement utilisées en bio-informatique, en finance, en intelligence artificiel et dans le traitement de l’information.
Elles cherchent à produire automatiquement des règles à partir d’un ensemble de données d’apprentissage contenant des “exemples” de données qualifiées.

Les SVM sont principalement exploitées pour leur capacité de traitement des données de grandes dimensions. En général, les machines à vastes marge ont des propriétés supérieurs, ou au moins égales, à celle d’un système d’apprentissage par réseau de neurones.

Dans le principe les SVM permettent de résoudre des systèmes discriminant et de régression en prédisant une valeur grâce à une fonction. Par exemple, il est possible de séparer automatiquement deux ensembles de valeurs par l’intermédiaire d’un hyperplan. Ceci permet de classifier des données projetées.

Comme présenté sur le schéma, les SVM tentent de diviser les deux ensembles de données avec la plus grande marge sur tous les cotés de l’hyperplan. Dans cet exemple, on part de l’hypothèse implicite que la plus grande marge ou la distance entre les ensembles de données et l’hyperplan la plus élevées est la meilleure. Ce système de classification automatique peut par exemple être utilisé pour le traitement d’informations nuisibles.

Application simple des SVM

Le contexte étant posé, je vous propose une petite application concrète.
Dans le cadre qui m’intéresse, je souhaite classifier les tweets automatiquement. C’est à dire pourvoir prédire les tweets qui m’intéresseront et ceux qui m’intéresseront moins. Pour simplifier, on peut dire que les tweets sont des ensembles de termes séparés par des espaces. On peut donc les assimiler à des vecteurs de n dimension, où n représente le nombre de termes.

Par exemple voici 3 tweets

twittos1: j'aime les pommes
twittos2: j'aime le nouvel iphone qui est terrible. Vivement sa sortie #iphone #apple
twittos3: j'attends avec impatience le nouvel iphone #Apple.

Premièrement, il faut nettoyer les données. Tous les caractères sont transformées en minuscule. Puis, on applique un filtre, généralement appelé “stoplist” qui permet de supprimer tous les termes ne possédant pas de sens pour notre application: le, est, la, les, à, etc. On va se retrouver avec des termes suivant dont nous allons indexer: aime → 1, pomme → 2, nouvel → 3, iphone → 4 , terrible → 5, vivement → 6, sortie → 7, apple → 8, attends → 9, impatience → 10

On pourrait aussi passer ces termes à un analyser lexical, souvent appelé processus de lemmatisation afin d’obtenir le lemme de chaque terme, c’est à dire la forme canonique. Par exemple pour n’avoir que les verbes l’infinitif.

Chaque tweets devient un vecteur sur notre espace à 10 dimensions. Si nous constatons la présence d’un terme sur le tweet, on met 1, etc.

tweet 1 -> [1, 1, 0, 0, 0, 0, 0, 0, 0, 0]
tweet 2 -> [1, 0, 1, 1, 1, 1, 1, 1, 0, 0]
tweet 3 -> [0, 0, 1, 1, 0, 1, 0, 1, 1, 1]

Nous avons aussi la matrice de qualification du corpus d’apprentissage: [0, 1, 1]. Le nombre de colonnes correspond au nombre de documents. Ici, j’indique que seuls les deux derniers documents me semble intéressant.

Classification des tweets

Plutôt que de vous présenter en détail les calculs, je vous propose une implémentation des SVM en ruby. J’ai commencé par mettre toutes les données dans une base sqlite. J’ai qualifié manuellement mes tweets qui m’intéressaient au moyen d’une petite application Ruby On Rails. Il suffisait d’un tableau présentant la liste des tweets. Sur chaque ligne, j’ai ajouté une liste déroulante afin de définir à quel corpus d’apprentissage le tweet correspondait. D’habitude j’utilise ActiveRecord pour la connexion avec la base de données. Cette fois, j’ai utilisé Sequel. Pour de plus gros volumes de données, je recommande de ne pas hésiter à utiliser MySQL ou Postgres.

#encoding: utf-8

require 'rubygems'
require 'sequel'
require 'SVM'
include SVM

DB = Sequel.sqlite
  
tweets_status = DB[:tweets_status] #table où sont qualifiés les tweets [0, 1, 1, 0, ...]
tweets = DB[:tweets] #liste de l'ensemble des tweets en tableau ["j'aime les pommes", "j'aime mon iphone", ...]

train_tweets_status = DB[:train_tweets_status]  #tableaux de qualification des tweets [0, 1, 0] 
train_tweets = DB[:train_tweets] #le corpus d'apprentissage

dictionary = (tweets+train_tweets).flatten.uniq #on génère un dictionnaire global regroupant l'ensemble de tout les termes des différents corpus

vectors = tweets.map { |tweet| dictionary.map{|w| tweet.include?(w) ? 1 : 0} }
train_vectors = train_tweets.map { |tweet| dictionary.map{|w| doc.include?(w) ? 1 : 0} }

pa = Parameter.new
pa.C = 100
pa.svm_type = NU_SVC
pa.degree = 1
pa.coef0 = 0
pa.eps= 0.001

sp = Problem.new

tweets_status.each_index do |i|
  sp.addExample(tweets[i], vectors[i])
end

kernels = [LINEAR, POLY, RBF, SIGMOID]
kernel_names = [ 'Linear', 'Polynomial', 'Radial basis function', 'Sigmoid' ]
m = nil

kernels.each_index do |j|
  pa.kernel_type = kernels[j]
  m = Model.new(sp, pa)
  ec = 0

  tweets.each_index do |i|
    pred, probs = m.predict_probability(vectors[i])
    #puts "Prediction #{pred}, True label: #{labels[i]}, Kernel: #{kernel_names[j]}"
    ec += 1 if labels[i] != pred
  end
  puts "kernel #{kernel_names[j]} => #{ec} errors on the training data"

  ec = 0
  test_labels.each_index do |i|
    pred, probs = m.predict_probability(train_vectors[i])
    puts "\t Prediction: #{pred}, True label: #{test_labels[i]}"
    ec += 1 if train_labels[i] != pred
  end

  puts "Kernel #{kernel_names[j]} => #{ec} errors on the test data \n\n"
end

Prochaines étapes

Avec un plus gros volume de données les calculs risques d’être plus long. Je présenterai donc dans un prochain article la ré-implémenter de cette partie avec l’aide de Hadoop et notamment Map/Reduce afin d’effectuer des calculs parallèles.
A savoir, on peut aussi effectuer de la classification en utilisant les statistiques bayesiennes. Je vais aussi essayer de faire un article sur ces éléments.

Gestion de données massives

La Stanford university a publié un ensemble de textes sur la gestion des données massives. Ce point est de plus en plus problématique pour les entreprises. Quelque soit le secteur d’activité, il devient de plus en plus stratégique de donner du sens aux données de l’entreprise. Malgré les efforts fait sur les matériels, l’analyse de celles-ci lorsqu’elles sont volumineuses, reste complexe et long. Les algorithmes de traitement, jusqu’alors utilisées dans les domaines du data-mining et de la business intelligence, rencontrent leurs limites.

Afin de gérer de grands volumes de données, de plus en plus d’équipes se tournent vers les pratiques NoSQL Not Only SQL, parfois pour les mauvaises raisons. Pour le traitement massif de données, on peut aussi citer MapReduce. MapReduce permet de répartir et de paralléliser des calculs sur de volumineux corpus de données. Par exemple, pour le calcul de la fréquence d’apparition de termes dans des textes ou co-occurence (cas de l’algorithme TF-IDF).

Mining of Massive Datasets

De l'utilité des wireframes dans la conception d'applications web

Je viens de feuilleter une keynotes ayant pour objet la conception de wireframes. Aussi appelé prototypage, maquettage ou encore mockups, cette méthode permet de concevoir “dans le réel” une application web en se projetant directement dans l’interface web, l’expérience utilisateur et l’ergonomie générale.
Cette méthode permet de garantir la compréhension des besoins fonctionnels mais surtout d’impliquer les différents acteurs du projet. L’importance des maquettes réside dans le fait qu’elles ne font pas intervenir trop de détails. Lors de cette phase du projet, il est très important de garder une vision très large et globale. Les maquettes sont généralement sans couleur. Seul compte la position des éléments.

Dans les phases initiales d’un projet, beaucoup de clients ne savent pas vraiment ce qu’ils veulent. Par l’intermédiaire d’une maquette, il est donc plus facile de cadrer les demandes. Les intervenants peuvent exprimer clairement leurs idées. Les discussions sont plus faciles. Ceci a aussi pour effet d’impliquer l’ensemble des collaborateurs.

A mon sens, cette façon de concevoir les applications n’est pas assez exploitées par les agences. Pourtant avec l’arrivée des méthodes agiles ceci facilite les opérations de précision des besoins.

Comment utiliser les maquettes

Certains prestataires proposent que le client face lui même directement ses maquettes à partir d’un logiciel. Je suis contre cette idée. Mon expérience m’a généralement montré que le client essai d’exprimer d’un seul coup toutes ses idées. Et malheureusement, elles ne sont pas toutes bonnes à prendre…

Le but d’une maquette est véritablement de faire murir le projet en avançant étape par étape. Le prestataire doit donc jouer un rôle de conseil tant sur le plan technique que fonctionnel. Le client doit être accompagné dans cette démarche. Je pense que le maquettage doit résulter d’un travail d’équipe réalisé lors de petites réunions en comité réduit (4 personnes max.), puis être poursuivi par email. Les outils de maquettage permettant d’avance dans ce sens.

Dans un prochain article je présenterai les outils que j’utilise. En attendant je vous propose une keynote suivie de quelques ressources web

Keynote Kung-Fu: How to wireframe like a ninja

Quelques ressources sur les Wireframes

Principe de sécurité avec un échange Diffie Hellman en Ruby

Les années 70 ont été marquées par le développement de la cryptographie. Notamment par l’arrivée des systèmes à base de clés publiques et clés privées. Par exemple, RSA a été créé en 1977 par Ronald Rivest, Adi Shamir et Loanard Adleman et breveté par le MIT en 1983.
Le concept de clés privées/clés publique est très simple à présenter. Il faut imager que chaque individu souhaitant chiffrer ses correspondances possède une clé publique, connue de tous ainsi qu’une clé privée générée en fonction de la précédente.

Il faut bien comprendre que ces clés sont générées mathématiquement l’une en fonction de l’autre mais ne sont pas identiques. On peut dire qu’elles sont sœurs mais pas jumelles. En général, ces clés sont des nombres premiers de grande tailles supérieur à 1024 bits (je détaillerai par la suite).

Procédure de chiffrement

Généralement, le processus fonctionnel de chiffrement est très simple : lorsque Bob souhaite envoyer un message à Alice, celui-ci récupère la clé publique de Alice. Bob chiffre le message qu’il souhaite envoyer grâce à cette clé publique d’Alice. Il peut ainsi diffuser le message chiffré par un canal non sécurisé (en général Internet). Alice n’a plus qu’à déchiffrer le message grâce à sa propre clé privée.

Si Alice souhaite répondre à Bob. Elle récupère la clé publique de celui-ci, chiffre le message de réponse avec cette clé publique de Bob, l’envoi sur un canal non sécurisé. Bob déchiffre le message grâce à sa propre clé privée.

Comment cela est-il possible ?

Dans l’exemple ci-dessus on constate que des données sont privées et d’autres publiques. Tout ceci permet de chiffrer des données malgré que certaines informations passent en clair sur le réseau.

Le principe repose généralement sur la notion de groupe mathématique. Dans mon exemple ci-dessous, j’ai utilisé celui des entiers modulo p lorsque p est un nombre premier. Il faut utiliser la propriété (gb)a=(ba)b.

Ce protocole devient sécurisé lorsque que de grands nombres premiers sont utilisés. En effet, brute forcer le protocole en ne connaissant que les données publiques revient à poser le problème du logarithme discret. Par exemple, pour que Eve trouve gab à partir de ga et gb, l’un ou l’autre de ces éléments doivent être élevés à la puissance b (ou a) respectivement.

Principe d’un échange de clé Diffie-Hellman

Ce principe est différent de la procédure présentée ci-dessus. Mais le but reste le même: permettre un échange d’un clé privée par l’intermédiaire du transfère de données publiques pouvant être interceptées.

Ceci peut être codé en ruby. Voici le code:

#encoding: utf-8

#Permet un calcul rapide de: g^a mod p
def mod_exp(a,e,m)
  result = 1
  while e > 0
    result = (result * a) % m if e[0] == 1
    e = e >> 1
    a = (a * a) % m
  end
  return result
end

#VALEURS INITIALES

#g et p sont des nombres connus des agents (Alice, Bob). Ils peuvent être selectionnés arbitraitement par Alice lors de l'initialisation de la communication puis diffusés en clair
p=23 # p doit être un nb premier. Utiliser un nombre > à 1024bits (>309 chiffres)
g=3 # nb de base: groupe. Utiliser un nombre aléatoire tel que g < p

#PRINCIPE:

# Alice et Bob ont en commun un nombre premier p et une base g.
# Alice choisit un nombre secret a=6
a = 6 # Utiliser de préférence un nombre de 100 chiffres mininum.
# Elle envoie à Bob la valeur g^a [mod p] = 36 [23] = 16
#A = g**a % p # A = 3**6 % 23
A = mod_exp(g,a,p)
puts "Alice envoie à Bob: g=#{g}, p=#{p}, A=#{A}"

# Bob choisit à son tour un nombre secret b=15
b = 15 # Utiliser de préférence un nombre de 100 chiffres mininum.
# Bob envoie à Alice la valeur g^b [mod p] = 315 [23] = 12
#B = g**b % p # B = 3**15 % 23
B = mod_exp(g,b,p)
#send("Alice",B)
puts "Bob envoie à Alice: B=#{B}"

# Alice peut maintenant calculer la clé secrète commune K => (g^b [mod p])^a [mod p] = 126 [23] = 9
#kAlice = B**a % p
kAlice = mod_exp(B,a,p)
puts "kAlice = #{kAlice}"
# Bob fait de même et obtient la même clé, K, que Alice : (g^a [mod p])^b [mod p] = 1615 [23] = 9
#kBob = A**b % p
kBob = mod_exp(A,b,p)
puts "kBob   = #{kBob}"

Débuter avec Ruby On Rails

De plus en plus de développeurs s’intéressent à Ruby On Rails. C’est une bonne chose car ce framework de développement web est vraiment mature. La version 3.1 vient tout juste de sortir.

Il existe une véritable communauté autour de ce framework. Mais par où commencer ?
J’ai essayé de recenser les principaux sites web de référence sur ce sujet.

Sites web sur Ruby On Rails

Tout d’abord, il y a LE Guide. Il rassemble les principales orientations.
Suivi du tuto: Getting Started with Rails.
Un guide pas à pas Learning Rails the Zombie Way.
On retrouve des screencasts. Il y a Rails 3 Screencast Series.
Sans oublier le fameux Railscasts.
En screencasts payants, il y a Peepcode.
Niveau texte on peut retrouver Ruby on Rails Tutorial - Learn Rails by Example – de Michael Hartl.
L’API est très riche API RubyOnRails.
ASCIICasts reprend les videos de Railscasts au format texte..
Plusieurs tutoriels sur Nettuts+.
Un eBook gratuit sur Ruby: Humble Little Ruby Book.
Programming Ruby.
Learn To Program
The Litte Book Of Ruby
Ruby Learning
Learn Code The Hard Way
Ruby Essentials
Pour finir je vous propose le Cheat Sheet de Envylabs.

Je vais aussi essayer de faire rapidement un post sur la blogsphère francophone autour de Rails et Ruby, il y a notamment le blog de Camille Roux Ingénieur web Rails à Montpellier.

10 effets Instagram sous Photoshop

Je pense que vous devez connaitre l’application Intagram. En gros, c’est un réseau social permettant de partager des photos de la vie courante. La valeur ajoutée de cette application est essentiellement centrée autour des effets que l’on peut appliquer à ses photos. On retrouve notamment des effets rétro, vieillissant les clichés à la façon des vielles pellicules.
Le lien ci-dessous est un tutoriel présentant différentes techniques sous photoshop permettant d’arriver au même résultat. Je vous laisse le lire :)

10 Photoshop Actions to Create Instagram Style Effects

Chiffrement de données avec un tunnel SSH

La notion de chiffrement de flux de données est souvent associée aux VPN (Virtual Private Network – Réseau Privé Virtuel). Or il n’est pas souvent nécessaire de déployer ce type d’architecture. SSH peut suffire.

En effet, il est très facile d’utiliser une connexion SSH vers, par exemple, un serveur dédié.

Utilisation

Lancer la commande suivante dans un shell. Les paramètres “user” et “server” sont a adapter à votre configuration.

# ssh user@server -C -N -D 8080

Dans firefox, vous utilisez le mode SOCK avec les paramètres suivants

Le tour est joué ! Vous avez maintenant une connexion HTTP sécurisée entre votre poste et le serveur.

Exploiter un seul CPU sous linux

Lors de l’exécution d’une tache nécessitant des calculs importants sur un serveur, il peut être intéressant de n’utiliser qu’un seul coeur du processeur.
Pour réaliser ceci, il existe un utilitaire: Taskset.

Installation de Taskset

Sur sytème Redhat (et fedora, et centos), tasket se trouve dans le paquet util-linux.

# yum install util-linux

Utilisation

Pour utiliser la commande sur le processeur désigné par l’id 1, vous pouvez utiliser la commande ci-dessous:

taskset -c 1 mon_script.sh

Si vous comptez utiliser plusieurs coeurs pour exécuter un programme, il suffi de lancer la commande:

taskset -c 1,2,3 mon_script.sh

Sortie de Postgresql 9.1

Postgresql Global Development Group vient de nous informer de la sortie de Postgres 9.1. Cette nouvelle version comporte différentes évolutions, notamment la technique des "K plus proches voisins", la réplication synchrone afin de garantir un système de haute disponibilité dans une grappe de serveurs, des tables non tracées afin d'améliorer les performances des données volatiles et d'autres nouveautés que je vous laisserai découvrir.

A propos des K plus proches voisins

Cette technique est surtout utilisée dans le traitement de documents texte, notamment en recherche d'informations ou dans le Traitement Automatique du Langage (TAL). C'est une méthode non supervisée. En gros, le système apprend automatiquement grâce à un corpus de données et non de règles prédéfinies par les développeurs. La méthode permet de faire ressortir par rapport à un corpus les échantillons les plus proches en fonction du calcul d'une distance.

Cette méthode est par exemple utilisée dans le traitement des spams. Dans ce cadre, on part d'un corpus d'emails. Certains de ces email sont considérés comme étant des spams. L'annotation de ce corpus est faite à la main a priori. Lorsque l'utilisateur va recevoir un nouvel email, celui-ci va être comparé au corpus grâce par exemple au calcul de la fréquence d'apparition de termes. On va alors obtenir le calcul d'une distance. En général c'est un chiffre compris entre 0 et 1. Si ce chiffre est supérieur à seuil défini alors l'email est considéré comme spam.

Pour en savoir suivez ce lien: http://www.postgresql.org/.

Partage de liens

Aujourd'hui je partage avec vous quelques liens qui ont retenu mon attention.

Au menu: du web desgin. Le premier concerne 10 techniques et astuces de conception d'interface web. Le second lien met en évidence l'importance du texte dans la conception web. Suivi d'autres liens liés à l'actualité. Et enfin, un guide complet sur le design d'interface web "responsible". En gros, cela concerne la conception d'interface web en prenant en compte différents supports: desktop, tablette, mobile, etc.

Hello World en Ruby

Dans un précédent article, j’ai présenté un bout de cote en C++ très simple. Pour le fun voici la même chose en ruby.

#encoding: utf-8

class MaClasse
  attr_accessor :id

  def initialize(id = 1)
    puts "[+] Constructeur de MaClasse: #{self.id}"
  end

  def say_hello(name)
    puts "Hello #{name} from #{self.id}"  
  end
end

mc = MaClasse.new
mc.say_hello("World")

Juste du C++

On m’a récemment demandé une initiation au C++. Mais quelque chose de très light. Il n’était pas question d’aborder les pointeurs. Mon idée était de montrer uniquement l’aspect objet de C++. Voici donc un bout de code très simple.
Il se compose:

du programme principal: hello.cpp.
d’un fichier entête d’une classe: ma_classe_.h
du code d’une classe: ma_classe.cpp

Le fichier hello.cpp est la partie principale du programme. C’est ici que les classes vont être instanciées en objet.

On retrouve aussi l’entête (ma_classe.h) et le code (ma_classe.cpp). Dans le premier fichier on déclare les fonctions essentielles de la classe. Dans l’autre fichier, il y a la logique applicative.

# ma_classe.h

#include <iostream>
#include <string>

using namespace std;

class MaClasse{
  private:
    int id;

  public:
    MaClasse();
    MaClasse(int id);
    ~MaClasse();

    void sayHello();
    void sayHello(string name);
}; //Ne pas oublier ce point virgule !!!

Dans ma_classe.h, on trouve la déclaration de la classe: “class MaClasse{}”. La déclaration d’une variable de type entier: “int id”. On trouve aussi deux constructeurs. L’un sans argument l’autre avec: “MaClasse()” et “MaClasse(int id)”. Suivi du destructeur: “~MaClasse()”.
Et enfin, les fonctions accessibles par un objet.

# ma_classe.cpp

#include <iostream>
#include <string>

#include "ma_classe.h"

using namespace std;

MaClasse::MaClasse(){
  this->id = 0;
  cout << "[+] Constructeur de MaClasse: " << this->id << endl;
}

MaClasse::MaClasse(int id){
  this->id = id;
  cout << "[+] Constructeur de MaClasse: " << this->id << endl;
}


MaClasse::~MaClasse(){
  cout << "[-] Destructeur de MaClasse: " << this->id << endl;
}

void MaClasse::sayHello(){
  cout << "Hello from MaClasse: " << this->id << " !" << endl;
}

void MaClasse::sayHello(string name){
  cout << "Hello " << name << " from MaClasse: " << this->id << " !" << endl;
}

# hello.cpp

#include <iostream>
#include <string>

#include "ma_classe.h"

using namespace std;

int main(){
  
  //Exemple instanciation statique
  MaClasse mc1(1);
  mc1.sayHello("World");
  
  //Exemple instanciation dynamique
  string name = "World";
  MaClasse *mc2 = new MaClasse(2);
  mc2->sayHello(name);
  delete mc2;

  return 0;
}

Pour compiler ce petit programme

repertoire$ g++ hello.cpp ma_classe.cpp -o hello
repertoire$ ./hello 
[+] Constructeur de MaClasse: 1
Hello World from MaClasse: 1 !
[+] Constructeur de MaClasse: 2
Hello World from MaClasse: 2 !
[-] Destructeur de MaClasse: 2
[-] Destructeur de MaClasse: 1

A propos

Sur Page de Geek, je publie des notes tournant autour du web et principalement de ses technologies. Plusieurs thématiques sont abordées:

L’architecture des technologies web
Ruby On Rails
Mysql, Postgresql et SQL
Les base de données NoSQL (MongoDB, Redis, Hadoop, etc.)
Le traitement de données (Map/Reduce, Data Mining, etc.)
La sécurité de l’information
Le référencement, SEO
Le Web Analytics
Html et CSS
Les univers Linux et Mac
Le web en général

A propos de moi ?

Très tôt, avant les années 2000, je suis tombé dans le chaudron d’internet. C’était l’époque des modems RTC, des disquettes, de Altavista, du langage Pascal, de SoftIce et d’autres geekeries. Je devais tout juste avoir 12 ou 13 ans. Depuis, je n’ai jamais vraiment quitté l’univers du web.

J’ai effectué un parcours universitaire atypique et pluridisciplinaire dans lequel j’ai évolué entre les technologies web, la communication, le design, le management de projet et la sécurité. J’ai eu plusieurs expériences professionnelles enrichissantes. Comme développeur web, développeur Java, architecte SI, directeur de projet. A ce jour, je travaille comme directeur technique au sein d’une société de communication.