supercalifragilisticexpialidocious Incanter-3

Incanter logo

Continuons notre voyage dans les sortilèges d’Incanter avec l’incantation de Mary Poppins,

supercalifragilisticexpialidocious

Le balai arrive. En route pour le monde où nos tableaux de nombres vont se ranger tout seuls !

Cet article fait partie d’une suite. L"épisode 1 présentait quelques bases de Clojure et Incanter.  L’épisode 2 présentait les types.

Où trouver des grimoires ?

Nous allons manipuler un peu plus d’API et quelques documents vont être bien utiles.

Clojure ainsi que la librairie présentent l’API complète ainsi que des cheat sheets pour regrouper les commandes les plus fréquentes.

To use or not to use ?

Les librairies sont organisées en modules. Pour utiliser une des formules magiques vous devez d’abord charger les librairies correspondantes.

user=> (use 'incanter.core)
nil
user=> (use 'incanter.io)
nil
user=> (use 'incanter.datasets)
nil

Un peu laborieux au bout d’un moment, non ?

use ou require sont des fonctions du package clojure.core qui chargent des librairies, c’est à dire un ensemble de ressources qui se trouvent dans un package Java. Un fichier Clojure à la racine de cette librairie sert de descripteur.

On a souvent à charger différentes librairies avec le même préfixe (par exemple incanter.core incanter.io …)
On peut réécrire ces lignes en plus compact en utilisant la forme suivante (prefix list).

user=> (use '(incanter core io datasets))
nil

Vous noterez que les librairies sont maintenant passées dans une liste. Le premier élément est le préfixe, les autres sont les librairies sans le prefixe. Attention, les noms passés dans la liste ne doivent pas contenir de . .

Et bien sûr une  ‘ pour empêcher l’évaluation de la liste.

Convoquer les données

Pour commencer, il vous faut quelques tableaux de nombres.

Incanter propose un moyen rapide de créer un dataset à partir d’un fichier CSV. Si vous n’avez pas de données sous la main, Incanter est livré avec quelques jeux de données (http://liebke.github.com/incanter/datasets-api.html) que l’on peur charger en utilisant la fonction get-dataset.

Commençons avec un résultat de test JMeter transformé en CSV. Un tir étalon pour ne pas avoir trop de données pour le moment.

user=> (def data (read-dataset "/Users/cfalguiere/Workspaces/Diapason/report-data/20111217-ETALON_WSW_TPS2011.csv" :header true))
#'user/data

Petite vérification, avons nous bien des données ? capture d'écran du résultat de view

user=> (view data)
#<JFrame javax.swing.JFrame[frame1,0,22,400x600,invalid,layout=java.awt.BorderLayout,title=Incanter Dataset,resizable,normal,defaultCloseOperation=HIDE_ON_CLOSE,rootPane=javax.swing.JRootPane[,0,22,400x578,invalid,layout=javax.swing.JRootPane$RootLayout,alignmentX=0.0,alignmentY=0.0,border=,flags=16777673,maximumSize=,minimumSize=,preferredSize=],rootPaneCheckingEnabled=true]>
user=>

La fonction view permet de visualiser ce dataset.

Combien êtes vous ?

La fonction de dénombrement Clojure est count.

user=> (count [1 2 3])
3
user=> (count "Incanter")
8

Donc voilà

user=> (count data)
2

Mmmmm … 2 … ???

Regardons de plus près à quoi ressemble ce dataset.

user=> data
#:incanter.core.Dataset{
  :column-names [:lb :t :lt :ts :s :rc :rm :by :na],
  :rows (
    {:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"}
    {:na 1, :by 28383, :rm "OK", :rc 200, :s "false", :ts 1.324109266396E12, :lt 8511, :t 8523, :lb "/CategoryDisplay"}
    ;...
    {:na 1, :by 861, :rm "OK", :rc 200, :s "true", :ts 1.324109908066E12, :lt 21, :t 21, :lb "/AjaxLastViewedDisplay"}
  )}

Le dataset est une map composée de 2 éléments :column-names qui contient tous les labels de colonnes dans un vector et :rows qui est une liste comportant une map par ligne de données.

On obtient un résultat plus pertinent en comptant les entrées de la liste. Incanter fournit aussi une fonction nrow qui compte correctement les lignes d’un dataset (n’oubliez pas que le dataset n’est pas une structure de données Clojure)

user=> (count (:rows data))
119
user=> (nrow data)
119

Le count de l’élément :rows de data nous donne bien le même compte que le nrow du dataset.

Découper en tranches

Quelques incantations Clojure pour se faire la main. Affectons les lignes du dataset a une variable pour les manipuler plus facilement.

user=> (def datarows (:rows data))
#'user/datarows
La Clojure way

Donne moi les deux premières lignes !

user=> (take 2 datarows)
({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 28383, :rm "OK", :rc 200, :s "false", :ts 1.324109266396E12, :lt 8511, :t 8523, :lb "/CategoryDisplay"})

Donne moi tous les labels !

On va utiliser la fonction map pour appliquer à chaque ligne une fonction qui renvoie le label.

user=> (map :lb datarows)
("/" "/CategoryDisplay" "/--product--.html" ...

Et tout à la fois !

user=> (take 2 (map :lb datarows))
("/" "/CategoryDisplay")
L’Incanter way

Incanter propose des fonctions de manipulation de dataset. La fonction utilisée pour extraire des données est sel plus souvent utiilisée via son alias $.

L’alias $ a plusieurs formes. Il peut être utilisé avec la colonne seule (identifié par sa position, son nom, ou une collection de ces indications), ou bien la ligne et la colonne. Le dernier paramètre est le dataset.

La fonction sel place le dataset en premier argument et spécifie l’axe par des keywords.

Donne moi tous les labels !

user=> ($ :lb data)
("/" "/CategoryDisplay" "/--product--.html" ...
user=> (sel data :cols 0)
("/" "/CategoryDisplay" "/--product--.html" ...

Un usage typique est celui-ci, extraire une série, ici le temps de réponse et calculer un agrégat tel que la moyenne :

user=> (mean ($ :t data) )
1429.579831932773

Vous avez testé et ça ne marche pas, jeune sorcier ? C’est normal, il faut le package incanter.stats qui n’a pas été chargé pour le moment.

Donne moi les deux premières lignes !

Pour la fonction sel le paramètre qui suit :rows indique soit un numéro particulier de ligne, soit une liste de numéros de lignes, soit un range qui va générer cette liste de numéros de lignes.

Lorqu’on utilise $ le premier paramètre représente la ligne (ou les lignes) et le second la colonne.

user=> (sel data :rows (range 2) )
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 28383, :rm "OK", :rc 200, :s "false", :ts 1.324109266396E12, :lt 8511, :t 8523, :lb "/CategoryDisplay"})}
user=> (sel data :rows '(0 1))

Ce qui est équivalent à :

user=> ($ (range 2) :all data)
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 28383, :rm "OK", :rc 200, :s "false", :ts 1.324109266396E12, :lt 8511, :t 8523, :lb "/CategoryDisplay"})}

Vous noterez le :all. La syntaxe oblige à spécifier deux paramètres si l’on veut indiquer des lignes, les lignes puis les colonnes. :all indique que toutes les colonnes doivent être conservées.

Donne moi les labels des cinq premières lignes !

user=> user=> ($ (range 5) :lb data)
("/" "/CategoryDisplay" "/--product--.html" ...
user=> (sel data :rows (range 5) :cols :lb)
("/" "/CategoryDisplay" "/--product--.html" ...

Toutes sortes de combinaisons sont possibles. L’expression suivante retourne un dataset ne comportant plus que les colonnes sélectionnées et les deux premières lignes.

user=> ($ (range 2) [:lb :t] data)
#:incanter.core.Dataset{:column-names [:lb :t], :rows ({:t 808, :lb "/"} {:t 8523, :lb "/CategoryDisplay"})}

S’il y a plusieurs colonnes, le résultat est un dataset, mais s’il n’y a qu’une ligne la structure de données est également différente. Le résultat est une liste et non un map. Les éléments sont ordonnés conformément aux colonnes du dataset.

user=> (sel data :rows 0)
("/" 808 794 1.324109256665E12 "false" 200 "OK" 27985 1)
user=> (:column-names data)
[:lb :t :lt :ts :s :rc :rm :by :na]

Pour finir, il existe un mot clé :not qui permet d’exprimer des listes par exclusion. Dans l’exemple suivant, l’expression conserve toutes les colonnes sauf :by et :na pour les deux premières lignes.

user=> ($ (range 2) [:not :by :na] data)
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm], :rows ({:rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:rm "OK", :rc 200, :s "false", :ts 1.324109266396E12, :lt 8511, :t 8523, :lb "/CategoryDisplay"})}

Trouver l’élu

Attention jeune sorcier ça se complique.

Pour analyser les résultats on aura souvent besoin de retrouver des sous ensemble sur des critères particuliers, tous les relevés pour une url données (:lb), les relevés avec des temps très élevés (:t), ou les relevés en erreur (statut :s, return code :rc, message :rm).

La Clojure way

Les collections Clojure ont une fonction filter filter. La ligne suivante donne tous les nombres pairs du vecteur [1 2 3 4 5 6].

user=> (filter even? [1 2 3 4 5 6])
(2 4 6)

Dans le cas plus général on ne pourra pas utiliser une fonction existante et il faudra écrire sa propre fonction filtre.

user=> (defn filterAlice [name] (= name "Alice"))
#'user/filterAlice
user=> (filter filterAlice ["Alice", "Bob", "Charles"])
("Alice")

D’une manière générale on utilisera plutôt une fonction anonyme. Ce qui nous donne :

user=> (filter (fn[name](= name "Alice")) ["Alice", "Bob", "Charles"])
("Alice")

C’est un peu verbeux et vous trouverez plus souvent une forme abrégée utilisant #.

user=> (filter #(= % "Alice" ) ["Alice", "Bob", "Charles"])
("Alice")

# est appelé la macro dispatch et a plusieurs effets décrits ici. Celui qui nous intéresse ici est #(...) qui est un équivalent de (fn [args] (...)).

user=> ( #(+ 1 %) 2 )
3
user=> ( #(+ 1 %1 %2) 2 3 )
6

% représente  l’argument, ou les arguments, de la fonction anonyme, ici le paramètre :name implicite.

Cette fonction anonyme appliquée sur la liste de prénom donne bien le même résultat.

user=> (filter #(= % "Alice") ["Alice", "Bob", "Charles"])
("Alice")

Et sur mes données maintenant ?
Donne moi toutes les lignes dont le label est "/" !

user=> (filter #(= % "/") datarows)
()

C’est vide ? Normal, chaque ligne de la liste est une map. Il faut donc récupérer le :lb.

user=> (filter #(= (:lb %) "/") datarows)
({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 27974, :rm "OK", :rc 200, :s "false", :ts 1.324109395646E12, :lt 209, :t 213, :lb "/"} {:na 1, :by 27994, :rm "OK", :rc 200, :s "false", :ts 1.324109537182E12, :lt 247, :t 252, :lb "/"} {:na 1, :by 27983, :rm "OK", :rc 200, :s "false", :ts 1.324109682199E12, :lt 344, :t 349, :lb "/"} {:na 1, :by 27980, :rm "OK", :rc 200, :s "false", :ts 1.32410980267E12, :lt 212, :t 217, :lb "/"})

Autre critère, les temps supérieurs à 10s ? Changeons simplement de fonction pour  #(> (:t %) 10000).

user=> (filter #(> (:t %) 10000) datarows)
({:na 1, :by 172777, :rm "OK", :rc 200, :s "true", :ts 1.324109405557E12, :lt 1398, :t 13007, :lb "/CategoryDisplay-REF"} {:na 0, :by 33268, :rm "OK", :rc 200, :s "true", :ts 1.324109406957E12, :lt 11602, :t 11607, :lb "http://www.witre.se/spannare_85915M.html?leafcode=85919&fromSearch=true"})

Et pour finir comment exprimer la négation ? Par exemple, trouver tous les relevés dont le statut n’est pas OK.

user=> (count (filter #(= (:rm %) "OK") datarows))
97
user=> (count (filter #(not= (:rm %) "OK") datarows))
22
user=> (count (remove #(= (:rm %) "OK") datarows))
22

Le total fait bien 119. Deux solutions sont possibles, remove ou filter avec l’expression complémentaire. La fonction remove n’altère pas la liste initiale.

L’incanter Way

Incanter propose la fonction query-dataset. Cette fonction a elle aussi un alias $where.

Les prédicats de query-dataset peuvent être exprimés dans un langage voisin du langage de requête de MongoDB.

Donne moi tous les relevés de la home page !

Ces relevés sont ceux dont la colonne :lb vaut "/".

user=> (query-dataset data {:lb "/"} )
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 27974, :rm "OK", :rc 200, :s "false", :ts 1.324109395646E12, :lt 209, :t 213, :lb "/"} {:na 1, :by 27994, :rm "OK", :rc 200, :s "false", :ts 1.324109537182E12, :lt 247, :t 252, :lb "/"} {:na 1, :by 27983, :rm "OK", :rc 200, :s "false", :ts 1.324109682199E12, :lt 344, :t 349, :lb "/"} {:na 1, :by 27980, :rm "OK", :rc 200, :s "false", :ts 1.32410980267E12, :lt 212, :t 217, :lb "/"})}

La même chose exprimée avec l’alias $where

user=> ($where {:lb "/"} data)
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 27974, :rm "OK", :rc 200, :s "false", :ts 1.324109395646E12, :lt 209, :t 213, :lb "/"} {:na 1, :by 27994, :rm "OK", :rc 200, :s "false", :ts 1.324109537182E12, :lt 247, :t 252, :lb "/"} {:na 1, :by 27983, :rm "OK", :rc 200, :s "false", :ts 1.324109682199E12, :lt 344, :t 349, :lb "/"} {:na 1, :by 27980, :rm "OK", :rc 200, :s "false", :ts 1.32410980267E12, :lt 212, :t 217, :lb "/"})}

On peut aussi exprimer plusieurs critères. Ci-dessous, les temps entre 8s et 10s.

user=> (query-dataset data {:t {:$gt 8000 :$lt 10000} } )
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ({:na 1, :by 28383, :rm "OK", :rc 200, :s "false", :ts 1.324109266396E12, :lt 8511, :t 8523, :lb "/CategoryDisplay"} {:na 1, :by 33235, :rm "OK", :rc 200, :s "true", :ts 1.324109282891E12, :lt 8967, :t 8981, :lb "/--product--.html"} {:na 1, :by 30959, :rm "OK", :rc 200, :s "false", :ts 1.324109547672E12, :lt 8787, :t 8792, :lb "/CategoryDisplay"})}

Ou bien les code retours qui ne font pas partie de la liste acceptée, 200 (OK) ni 302 (redirect).

user=> (query-dataset data {:rc {:$nin #{200 302} } } )
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ()}
user=> (query-dataset data {:rm {:$nin #{"OK" "Found"} } } )
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ()}

Les opérateurs disponibles dans les requêtes sont :$gt, :$lt, :$gte, :$lte, :$eq, :$ne, :$in, :$nin, $fn.

Les prédicats peuvent également être définis de manière classique par une fonction anonyme. La fonction s’applique à la ligne.

user=> (query-dataset data #(= (:lb %) "/" ) )
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 27974, :rm "OK", :rc 200, :s "false", :ts 1.324109395646E12, :lt 209, :t 213, :lb "/"} {:na 1, :by 27994, :rm "OK", :rc 200, :s "false", :ts 1.324109537182E12, :lt 247, :t 252, :lb "/"} {:na 1, :by 27983, :rm "OK", :rc 200, :s "false", :ts 1.324109682199E12, :lt 344, :t 349, :lb "/"} {:na 1, :by 27980, :rm "OK", :rc 200, :s "false", :ts 1.32410980267E12, :lt 212, :t 217, :lb "/"})}

Si vous avez déjà des fonctions dans vos grimoires, vous pouvez bien sûr les utiliser directement.

user=> (defn isHomePage [row] (= (:lb row) "/"))
#'user/isHomePage
user=> (query-dataset data isHomePage )
#:incanter.core.Dataset{:column-names [:lb :t :lt :ts :s :rc :rm :by :na], :rows ({:na 1, :by 27985, :rm "OK", :rc 200, :s "false", :ts 1.324109256665E12, :lt 794, :t 808, :lb "/"} {:na 1, :by 27974, :rm "OK", :rc 200, :s "false", :ts 1.324109395646E12, :lt 209, :t 213, :lb "/"} {:na 1, :by 27994, :rm "OK", :rc 200, :s "false", :ts 1.324109537182E12, :lt 247, :t 252, :lb "/"} {:na 1, :by 27983, :rm "OK", :rc 200, :s "false", :ts 1.324109682199E12, :lt 344, :t 349, :lb "/"} {:na 1, :by 27980, :rm "OK", :rc 200, :s "false", :ts 1.32410980267E12, :lt 212, :t 217, :lb "/"})}

Voilà, beaucoup de sortilèges a expérimenter en attendant l’épisode 4. Attention à ne pas faire trop de dégâts !

1, 2, 3 . . . Incanter

Incanter logoCet article est la suite de cet article abracadabra ! Incanter.

Pour traiter des données statistiques, les structures de données qui nous intéressent principalement sont les nombres et les tableaux de nombres.

Clojure utilise les types de données classiques pour représenter des textes String, Character, des Boolean (true/false), des nombres, plusieurs types de collections et deux types d’identifiants.

La documentation de l’interpréteur décrit de manière assez rapide les différents types de données http://clojure.org/reader.  Ce document http://clojure.org/data_structures décrit les structures de données disponibles de manière un peu plus approfondie. J’ai aussi trouvé ce document utile http://en.wikibooks.org/wiki/Learning_Clojure/Data_Types.

Les textes

Clojure repose sur les types Java. Donc java.lang.String et la manipulation des chaînes n’est pas très différente. Quelques opérations utiles :

user=> (type "A")
java.lang.String
user=> (str 144 " éléments") ; concatène les deux termes
144 éléments
nil
user=> (count "Incanter") ; compte le nombre de caractères de la chaîne
8

La quote ‘ a une signification particulière dans la syntaxe Clojure (on le verra plus loin). Il ne peut pas être utilisé pour les caractères. Les caractères sont définis par \. Il existe aussi des caractères spéciaux comme \tab \newline \space

user=> (type 'A')
java.lang.Exception: Unmatched delimiter: )
user=> (type \A)
java.lang.Character
user=> (println \A \tab \B)
A
        B
nil

Les identifiants

Clojure a 2 types d’identifiants, symbol et keyword.

Les  symbol sont des identifiants qui référencent quelque chose d’autre. Ce sont en général des noms de variable, de fonction, de classe.

Les keyword sont des identifiants qui référencent leur nom. Ce sont des sortes de chaînes constantes donc plus rapides à comparer. Elles sont principalement utilisées comme clés dans les hash-maps ou les méta-données des symbol. Un : est placé devant les keyword, mais il ne fait pas partie de son nom.

Ci-dessous la déclaration d’une variable avec un symbol x . On ne peut pas faire la même chose avec un keyword.

user=> (def y 1)
#'user/y
user=> y
1
user=> (def :y 1)
java.lang.Exception: First argument to def must be a Symbol (NO_SOURCE_FILE:221)
</code

Les keyword sont utilisés comme label dans les hash-maps. On voit que le keyword Alice retourne son nom.

user=> (def scores {:Alice 1, :Bob 2} )
#'user/scores
user=> (get scores :Alice)
1
user=> :Alice
"Alice"

Les  keyword sont aussi utilisés dans la définition des méta-données. Le nom de fonction hello est symbol. Un keyword :doc est utilisé pour ajouter une description. Les  keyword ne peuvent pas avoir de méta-données.

user=> (defn
  ^{:doc "pas très utile"}
  hello ([name] (println "Hello" name)))
#'user/hello
user=> (doc hello)
-------------------------
user/hello
([name])
  pas très utile
nil

Les symbol peuvent être utilisés là où des keyword seraient utilisés (même si c’est sans grand intérêt).
Essayons pour voir.
On ne peut pas utiliser le  symbol directement.

user=> (def scores {Alice 1, Bob 2})
java.lang.Exception: Unable to resolve symbol: Alice in this context (NO_SOURCE_FILE:375)

Contrairement aux keyword qui se résolvent sur eux même, les symbol tentent d’évaluer ce qu’ils référencent dès qu’on les utilise. Le keyword :Alice renvoie "Alice". Le symbol Alice ne peut pas être évalué car il n’existe pas encore, et si on prend un symbol existant dans le contexte tel que y, il renvoie 1 dès qu’on utilise ce nom.

user=> :Alice
"Alice"
user=> (name y)
java.lang.ClassCastException: java.lang.Integer cannot be cast to clojure.lang.Named (NO_SOURCE_FILE:0)
user=> y
1
user=> (name :Alice)
"Alice"

Le ‘ permet d’empêcher l’évaluation de l’expression et d’utiliser le symbol non évalué comme label.

user=> 'y
y
user=> (name 'y)
"y"user=> (def scores {'Alice 1, 'Bob 2}) ; pour démo, on utiliserait normalement :Alice :Bob
#'user/scores
user=> (get scores 'Bob)
2

Les nombres

Les nombres sont toujours "boxés" c’est à dire contenus dans un objet comme Integer pour le type int. Ces types sont dérivés de java.lang.Number.

Quelques différences avec Java. Pour les entiers, Clojure gère automatiquement la conversion vers des BigNum et ajoute un type Ratio. Pour les décimaux, ce sont par défaut des Doubles et Clojure préserve la précision lors des opérations numériques qui impliquent un Double.

La représentation de la constante influence le type. M indique un BigNumber et le . un décimal comme en Java.

user=> (type 1)
java.lang.Integer
user=> (type 1.0)
java.lang.Double
user=> (type 1M)
java.math.BigDecimal

Quelque soit le type de départ, le type est adapté pour contenir la valeur sans la tronquer lors des opérations arithmétiques. Un souci de moins.

user=> (type 123456789)
java.lang.Integer
user=> (type (* 123456789 123456789))
java.lang.Long
user=> (type (* 123456789 123456789 123456789))
java.math.BigInteger

Quelque soit le type utilisé les opérations de comparaison entre des types différents restent cohérentes.

user=> (== 1 1.0)
true
user=> (== 1.0 1M)
true
Ratio et divisions

Une spécificité de Clojure, le type Ratio permet de représenter les fractions d’entiers sans perte de précision. Il ne s’applique qu’aux entiers. La même opération retourne un décimal dès qu’une des valeurs est décimale.

user=> (/ 2 3)
2/3
user=> (type (/ 2 3)) ;; opération sur entiers
clojure.lang.Ratio
user=> (/ 2 3.0)
0.6666666666666666
user=> (type (/ 2 3.0)) ;; opération sur un entier et un décimal
java.lang.Double
user=> (/ 4 2) ;; opération sur entiers
2
user=> (type (/ 4 2) )
java.lang.Integer

Si on veut faire une division sur entiers, il faut coercer une des valeurs en float ou en double.

user=> (type (float 2))
java.lang.Float
user=> ( / (float 2) 3 )
0.6666667
user=> (type ( / (float 2) 3 ))
java.lang.Float

Même si les nombre sont par défaut traités en Double, la conversion n’est pas systématique si elle n’est pas nécessaire. Une conversion en double aurait donné un Double.

user=> ( / (double 2) 3)
0.6666666666666666
user=> ( type ( / (double 2) 3) )
java.lang.Double
Les opérations

Maintenant qu’est ce que je peux faire avec mes nombres ?

user=> (pos? -2) ;; is positive ?
false
user=> (min 3 1 5) ;; min
1
user=> (max 4 8 2) ;; max
8
user=> (int 1.2) ;; coercion en entier
1
user=> (inc 2) ;; incrémente de 1
3
user=> (dec 5) ;; décrémente de 1
4

La plupart des fonctions acceptent n valeurs. Qu’est ce qui se passe si j’ai plusieurs paramètres ?

Le résultat est à assez évident sur min ou max. Moins sur d’autres opérateurs. Le résultat est spécifié dans la documentation. Par exemple pour /, le premier terme est divisé par tous les suivants.

user=> (/ 12 2 3)
2

Pour <, la documentation indique "Returns non-nil if nums are in monotonically increasing order, otherwise false." La suite doit être strictement croissante ? Mmm? testons …

user=> (< 1 2)
true
user=> (< 1 2 4)
true
user=> (< 1 5 4)
false

Encore plus de nombres

En général, lorsque l’on fait des statistiques on a de longs tableaux de nombres. Il nous faut donc des collections.

A quoi ça ressemble en Clojure ?

Les maps

Les maps sont représentées par {}. On en a vu un exemple plus haut. Les , sont facultatives mais améliorent la lisibilité. On peut utiliser tout type de valeurs comme clé (tout type de form dans la terminologie Clojure).

user=> (def scores { "Alice" 1, "Bob" 2} )
#'user/scores
user=> (type scores)
clojure.lang.PersistentArrayMap
user=> (get scores "Bob")
2
user=> (def scores { 15 "A", 22 "B"} )
#'user/scores
user=> (get scores 15)
"A"
Les listes

Les listes sont représentées entre (). C’est ce qu’on manipule depuis le début.

user=> user=> (def readings (1 2 3))
java.lang.ClassCastException: java.lang.Integer cannot be cast to clojure.lang.IFn (NO_SOURCE_FILE:398)

Diantre ! La magie ne marche pas sur les listes ?
Si, mais l’interpréteur évalue toutes les listes comme si c’est c’était des programmes.

Mais si on veut que la liste ne soit pas évaluées et restent des listes ??? Mmm J’ai déjà vu ça quelque part …

user=> (def readings '(1 2 3))
#'user/readings
user=> (type readings)
clojure.lang.PersistentList
user=> readings
(1 2 3)

La fonction range est un moyen rapide de générer une liste de nombres.

user=> (range -2 6)
(-2 -1 0 1 2 3 4 5)
Les vecteurs

Le vecteur est représenté entre [].

user=> (def persons [ "Alice" "Bob" "Charles"] )
#'user/persons
user=> (type persons)
clojure.lang.PersistentVector
user=> (persons 1)
"Bob"
user=> ([ "Alice", 2, :name ] 2)
:name

La liste et le vecteur  conservent l’ordre. La liste est à privilégier pour les accès séquentiels. Le vecteur permet un accès direct (par index) efficace.

Les sets

Il reste un dernier type de collection dans Clojure, le set qui maintient l’unicité. Il est représenté par #{}.

user=> #{1 3 1 4}
java.lang.IllegalArgumentException: Duplicate key: 1
user=> #{1 3 5 4}
#{1 3 4 5}
user=> (type #{1 3 5 4})
clojure.lang.PersistentHashSet
Quelques opérations sur les collections

La fonction doseq permet de parcourir l’itérateur de la collection.

user=>(def persons '( "Alice" "Bob" "Charles") )
user=> (doseq [p persons] (println p))
Alice
Bob
Charles
nil
user=> (count persons)
3

Toutes les callections sont modifiables.  conj permet d’ajouter des éléments. Attention l’effet de conj depend du type de collection.

user=> (conj '(1 2 3) 5)
(5 1 2 3)
user=> (conj [1 2 3] 5)
[1 2 3 5]
user=> (pop [1 2 3])
[1 2]

Un peu d’Incanter

Ah ! Quand même !

Incanter rajoute un type de donnée, la matrice. Une matrice ne peut contenir que des données numériques et n’a pas de nom de colonnes (même définition que dans R).

user=> (def A (matrix [[1 2 3] [4 5 6] [7 8 9]]))
java.lang.Exception: Unable to resolve symbol: matrix in this context (NO_SOURCE_FILE:450)

Whoops ! Jusqu’à présent tous les types étaient du Clojure. Ce type de données étant spécifique à Incanter, il faut charger la librairie en utilisant use. Et voilà ! matrix génère une matrice. Comme dans R, la matrice est un Vector replié.

user=> (use 'incanter.core)
nil
user=> (def A (matrix [[1 2 3] [4 5 6] [7 8 9]]))
#'user/A
user=> A
[1,0000 2,0000 3,0000
4,0000 5,0000 6,0000
7,0000 8,0000 9,0000]

Il existe différentes syntaxes pour créer des matrices à partir de vectors ou de listes. La syntaxe précédente concaténait des vecteurs lignes. Celle-ci découpe un vecteur en fonction du nombre de colonnes souhaitées.

user=> (def A2 (matrix [1 2 3 4 5 6 7 8] 2))
#'user/A2
user=> A2
[1,0000 2,0000
3,0000 4,0000
5,0000 6,0000
7,0000 8,0000]

Incanter ajoute également le type Dataset, qui est l’équivalent d’un tableau Excel ou d’une table en base de données. Le dataset comporte des noms de colonnes. Les colonnes peuvent être de tout type.

user=> (use 'incanter.datasets)
nil
user=> (dataset ["x1" "x2" "x3"]
[[1 2 3]
[4 5 6]
[7 8 9]])
#:incanter.core.Dataset{:column-names ["x1" "x2" "x3"], :rows ({"x3" 3, "x2" 2, "x1" 1} {"x3" 6, "x2" 5, "x1" 4} {"x3" 9, "x2" 8, "x1" 7})}

Ces structures de données sont généralement lues à partir de fichiers CSV ou d’une base de données.

user=> (use 'incanter.io)
nil
user=> (def data (read-dataset "datafile.csv" :header true))
nil

Et quelques statistiques pour finir et vous montrer qu’on n’a pas manipulé toutes ces collections pour rien aujourd’hui :

user=> (use ‘(incanter core stats) )
nil
user=> (mean ‘(20 10 30) )  ; médiane
20.0
user=> (sum ‘(20 10 30) )  ; somme
60.0

On reviendra en détail sur tout ça dans l’épisode 3.

abracadabra ! Incanter

Incanter logo
Et voilà, j’ai a nouveau un paquet de résultats de test à analyser. Une bonne occasion d’évaluer Incanter.
Incanter se définit comme "a Clojure-based, R-like platform for statistical computing and graphics.".

Un R-like ? R est une plate-forme et un langage dérivé de Scheme (lui même dérivé de LISP) qui permet de manipuler facilement des données statistiques (les lire depuis une source, les filtrer, calculer des moyennes, afficher ces valeurs sous forme de courbe ou d’histogramme, et bien d’autres fonctions pour statisticiens). Ok, mais ça fait à peu près ce que fait Excel. Oui, mais sous forme de langage ce qui permet de scripter bien plus facilement et surtout permet de traiter de grosses masses de données sans devoir les afficher.

Quel est le problème avec R ? C’est un outil génial mais qui existe dans un éco-système différent de Java et ne permet pas de réutiliser tout ce que l’on connait. Il est un peu lent et c’est un mix entre programmation fonctionnelle et C parfois un peu déroutant. Mais il bénéficie d’une communauté beaucoup plus grande et de beaucoup plus de fonctions que son challenger. Et puis quand même Incanter : Data Sorcery c’est indispensable d’aller voir.

Et c’est une bonne occasion de se mettre à Clojure aussi. Pour ceux et celles qui n’auraient pas fait de veille depuis 2 ans, Clojure est un dialecte de LISP (avec des (parenthèses) partout) qui tourne dans la JVM.

On s’y met

Assez tourné autour du sujet. Maintenant il faut regrouper quelques épices et mettre les mains dans le chaudron.

Pour commencer, il faut un environnement Clojure. Vu que le but c’est d’utiliser Incanter, autant utiliser la solution de fainéant avec un kit de magicien.

http://incanter.org/downloads/

Et une incantation ! (enfin un clic sur l’icône)
Mmm … non c’est bien ça.
Certes …
Effectivement, un R-like (encore que dans l’environnement R il y a deux ou trois trucs dans le menu).

incanter shell

J’ai bien réussi à faire une copie d’écran sur un Mac. Pas de soucis (encore que WordPress s’obstine a formater le code préformaté).

Le shell Clojure est un environnement interactif qui lit, evalue et affiche le résultat des expressions qu’on lui soumet. Il est souvent désigné  sous le nom REPL.

Tentons quelques trucs.

Clojure 1.2.0-master-SNAPSHOT
user=> (1+1)
java.lang.NumberFormatException: Invalid number: 1+1 java.lang.Exception: Unmatched delimiter: )
user=> ()
()
user=>

Soyons positifs, () marche … même si ça n’est pas très utile.

B-A-BA Clojure

Bon, commençons par le commencement, lire la doc. Vous trouverez des ressources sur http://data-sorcery.org/ qui est en fait le blog de incanter.org. Un peu trop compliqué de prime abord. J’ai trouvé là http://www.chicoree.fr/w/Premiers_pas_avec_Clojure un tutorial très progressif même si c’est appliqué à un sujet différent. J’en ai repris quelques éléments.

On veut manipuler des données. Donc on va faire des opérations sur des nombres. Comment on fait une opération ?

user=> (+ 1 2)
3

Et oui, en Clojure, les opérateurs sont préfixés.

Clojure est un langage homoiconique, il représente les programmes comme des structures de données. Le programme est donc représenté par une liste d’éléments. D’un point de vue plus technique, c’est une S-expression, c’est à dire une séquence de termes entre parenthèses. Le premier terme est la fonction à appliquer et les termes suivants sont des arguments. N’importe quel terme peut être une sous-expression. L’opérateur + est une fonction comme une autre.

Ce qui  permet d’écrire un suite d’additions en passant la liste des valeurs ou d’appliquer une méthode à un objet (vous noterez le . et le fait que la méthode précède la chaîne à laquelle elle s’applique).

user=> (+ 1 2 3)
6
user=> (.toUpperCase "Hello")
"HELLO"

Conséquence de ce principe, il n’y pas de règles de précédence des opérateurs en Clojure, l’opérateur ne peut se trouver qu’au début de la séquence.

user=> (+ 1 (* 2 3))
7
user=> ; 1 + 2*3

Le symbole qui marque le début d’un commentaire est ;

Il existe aussi des fonctions prédéfinies telles que print ou println similaires au méthodes Java. Vous noterez que les , entre les termes sont facultatives.

user=> (print "Hello")
Hellonil
user=> (println "Hello", "Claude")
Hello Claude
nil
user=> (println "Hello" "Claude")
Hello Claude
nil

Mais d’ou sort ce nil ?

Les fonctions print n’ont pas de valeur de retour à la différence de +. L’affichage du texte est un effet de bord de la fonction. nil sert à plusieurs choses en Clojure, mais en particulier à exprimer la fin de séquence et le rien.

Encore quelques détails et nous voilà prêts à écrire Hello World.

Hello World !

Une fonction se définit en utilisant la fonction fn suivi des paramètres entre crochets et d’une expression qui définit le résultat à produire. Et le nom ? Est ce bien nécessaire d’avoir un nom ?

user=> (fn [name] (println "Hello" name))
#<user$eval61$fn__62 user$eval61$fn__62@10e9df>
user=> ( (fn [name] (println "Hello" name)) "Claude" )
Hello Claude
nil

Cette fonction anonyme est utilisable (enfin, pour peu qu’on mettre les parenthèses au bon endroit). Finalement, un nom c’est pratique. On va associer cette fonction à un nom en utilisant la même syntaxe que pour déclarer toute variable, la fonction def.

user=> (def moi "Claude")
#'user/moi
user=> (type moi)
java.lang.String
user=> (println moi)
Claude
nil

Et maintenant la fonction hello :

user=> (def hello (fn [name] (println "Hello" name)) )
#'user/hello

La fonction doc retourne des informations sur la fonction. A noter aussi plus haut, la fonction type.

user=> (doc hello)
-------------------------
user/hello
nil
   nil
nil
user=> (doc println)
-------------------------
clojure.core/println
([& more])
   Same as print followed by (newline)
nil

En pratique, les fonctions sont plutôt déclarées de la manière suivante, grace à la macro defn qui regroupe les deux étapes.

Hello world en Clojure.

user=> (defn hello [name] (println "Hello", name))
user=> (hello "Claude")
Hello Claude
nil

Et Incanter ?
Houlà !!! vous êtes bien pressé jeune sorcier. Il nous reste à voir les collections et quelques concepts secrets. Mais à chaque jour suffit sa peine. C’est tout pour aujourd’hui. La suite dans l’épisode 2.

Devoxx 2011 et les femmes

"The absence of women in tech is the elephant in the living room, it must be discussed" – Tim Bray – Conference Day 2 Keynote – Devoxx 2011

Tim Bray a commencé sa keynote par ce constat et annoncé la session "Why we shouldn’t target women". La salle 3 était pleine alors que nous attendions 20 personnes. Merci encore à Tim Bray pour sa keynote passionnante et pour nous avoir soutenu aussi efficacement.

Combien de femmes à Devoxx cette année ?

Pas des masses. 1% des participanta à Devoxx 2010 étaient des femmes. Le nombre n’est pas encore disponible pour cette année, mais il semble similaire.

Plus de femmes speakers en proportion cette année. Parmi les 167 speakers, 9 sont des femmes bien que 4 seulement aient donné des conférences ou des BOF techniques (Patrycja Wegrzynowicz Performance Anti-pattern in Hibernate, Lilli Thompson Cross platform game programming with PlayN, Birgitta Boeckeler Code generation at large, Sonya Barry BOF lessons from the java.net migration ) et 5 ont parlé lors du panel et du BOF sur les femmes dans l’IT ( Regina ten Bruggencate, Trisha Gee,Anna Gos, Kim Ross, Claude Falguiere )

Quatre speakers c’est plus que l’an dernier de toute manière. Inutile de blamer l’organisation Devoxx : peu de femmes dans l’IT conduit a peu de speakers feminins.

Les femmes sont de moins en moins nombreuses dans l’IT et les écoles d’informatique. Ce nombre a diminué de 40% dans les années 90 à  20% de nos jours. Pourquoi ? Quelqu’un a posé la question au panel. Malheureusement nous sommes les personnes les moins susceptibles de répondre à cette question et nous ne voulons pas faire d’hypothèses pour les autres. Vous trouverez plusieurs tentatives d’explication dans cet article  http://en.wikipedia.org/wiki/Women_in_computing.

Cette chute affecte aussi d’autres métiers scientifiques dans une moindre mesure mais à l’inverse le nombre de femmes dans le BTP augmente en dépit d’une image très masculine de ces métiers. Il est intéressant de noter que le nombre de femmes dans l’IT est de l’ordre de 50% dans les pays émergents en Asie, en Inde et au Brésil.

Un changement semble possible. Alors pourquoi nous ne devons pas cibler les femmes ?

Premièrement, est ce un problème de femmes ? L’absence de femmes est très visible. Mais d’autres minorités ne sont pas représentées non plus. Combien de speakers noirs ? 1. Combien de speakers agés …

Le secteur IT connait un problème de diversité. Il tend à cloner des hommes blancs jeunes avec le même type d’aptitudes.

Ce n’est pas seulement un problème d’équité. La diversité est nécessaire aux projets. Les projets IT nécessitent un mélange d’exploration de nouvelles technologie et de prudence, un mélange de rationalisation, d’imagination de communication, d’être en contact avec des utilisateurs aussi bien que des ops. L’IT a besoin de gens qui ont différents profils psychologiques et des trajectoires diverses.

Diversité des gens, diversité des emplois

Et si nous présentions l’IT comme une industrie avec un grand nombre d’activités qui vont du design à la programmation hard core, pour produire une grande variété d’applications, des sites webs, des applications pour smartphones aux systèmes de contrôle aérien ? Si nous présentions différents types d’informaticiens ?

! image-de-Geek : C’est fait

Quoi d’autre ?

Pourquoi pas une femme dans l’équipe parce que les femmes sont douées pour la communication, la conception d’IHM, ou quoi ce que ce soit d’autre ? Ce sont juste d’autres stéréotypes. Dans le panel, Kim aime être la maman de l’équipe, les autres non. Toutes les femmes n’aiment pas nourrir et soigner une équipe et à l’inverse certains hommes font cela très bien. Nous devons prendre en compte l’être humain pas la catégorie à laquelle il appartient.

OK mais alors comment pouvons nous accroître la diversité ?

Accueillir les nouveaux venus

Avez vous déjà essayé de vous joindre à un groupe de geeks débattant à propos du meilleur framework ? C’est intimidant, ils semblent si compétents. Les JUGs sont de bons endroits pour rencontrer des équipes de développement et découvrir des opportunités de postes intéressants. Mais les JUGs, particulièrement le ParisJUG parce qu’il est si grand, sont intimidants pour les nouveaux venus.

Accueillez les nouveaux venus. Aidez les à rentrer dans les discussions, préparez les sessions comme Duchess France le fait avant le ParisJUG, faites passer les informations que vous avez apprises dans les sessions précédentes, faites connaître les projets Open Source et aidez les à rejoindre ces communautés via des hackerspaces.

Le nouveau venu est une femme ? Génial ! Mais n’oubliez pas que les hommes aussi se sentent isolés et nouveaux.

Favorisez la confiance en soi

Les femmes manquent souvent de confiance en elles. Elles ne se sentent pas expertes, elles craignent d’être un mauvais speaker, elles ont peur de se surévaluer. Que pouvons nous faire  ?  Parrainer, travailler en paire sont des moyens de mettre le pied à l’étrier et d’améliorer la confiance en soi.

Et les filles, armez vous de courage et allez y. Parler à 50 personnes, apprendre de nouvelles technologies est inconfortable pour les hommes aussi. Mais ils n’en parlent pas  ;-)

De temps en temps vous échouerez. Vous réfléchirez aux raisons, vous vous améliorerez et vous recommencerez.

Vous tomberez sur des gars qui affirmeront fièrement que le cerveau des femmes n’est pas cablé pour faire de l’informatique. Vous avez choisi de travaillez dans l’IT parce que vous aimez ce job. Rappelez vous vos projets réussis. Même si c’est vrai (je ne suis pas neurologue) et que c’est plus dur, et alors ?  Certaines y sont arrivées et vous y arriverez aussi.

Vous tomberez sur des speakers qui montreront des images blessantes comme dans le "Duct Tape talk" à Devoxx 2011 ( http://www.slideshare.net/ertmanb/devoxx-building-nextgeneration-enterprise-applications-in-java ). Ne vous sentez pas rejetées. Tout le monde pense que montrer des femmes dénudées dans un talk technique est inapproprié. Les plaisanteries sont amusantes autour d’une bière mais pas quand la cible ne peut pas répondre.

Les monde est rempli de stéréotypes. Préparez vous à expliquer encore et encore qu’il y a des femmes dans l’IT et à montrer ce que vous savez faire jusqu’à ce qu’il y ait suffisamment de femmes pour casser ce stéréotype.

Etre parent

Une des choses que les femmes doivent gérer est la maternité et le fait d’élever des enfants.

Au lieu de rejeter les femmes parce qu’elles ont des enfants, nous devrions adapter cette industrie aux parents, en particulier les heures de travail. Antonio nous a montré que même les hommes veulent passer du temps avec leurs enfants.

Proaction pour la prochaine génération

Les auditeurs ont posé beaucoup de questions sur la pro-action. Doit on être pro-actifs sur l’emploi des femmes ? Doit on donner des tickets gratuits à toutes les femmes à Devoxx ?

Les actions positives sont souvent de mauvaises idées. Elles créent des inégalités. Certains hommes se sont plaint des files d’attente aux toilettes côté hommes alors que côté femme la file était vide. Qu’auraient ils dit si la fille à côté d’eux n’avait pas payé sa place ?

De plus les quotas peuvent amener à promouvoir des personnes qui ne sont pas qualifiées pour atteindre le quotas. Quelqu’un a posé une question sur comment se comporter avec un boss femme et plus jeune que soi. Est qu’elle était jeune et une femme, ou simplement pas encore préparée à ce job ?

Les gens apprennent par l’expérience. Les femmes doivent avoir des carrières normales, apprendre, devenir la personne la plus qualifiée et promues parce qu’elles méritent le poste. C’est la même chose pour les conférences. Ce serait une mauvaise idée de propulser des femmes qui n’ont jamais fait de présentations directement à Devoxx. Des tas de présentations données par des hommes sont mauvaises, mais une mauvaise présentation faite par une femme sera plus visible.

Vous voulez toujours être proactifs ? Préparez le futur.

Nous voulons tous voir de nouveaux visages dans les conférences, que ce soit des femmes ou des hommes. J’ai parlé à de nombreux JUG Leaders qui veulent amener plus de femmes dans leurs JUGs. Et bien vous les JUG Leaders avez la difficile tâche de promouvoir de nouveaux speakers et les faire connaître. Demandez aux femmes que vous connaissez de faire des présentations.

Les JUGs sont des lieux où il est facile de commencer comme speaker car l’audience est réduite et que l’enjeu est faible. La présentation peut être donnée plusieurs fois dans divers lieux, ce qui permet de peaufiner les slides, d’améliorer ses capacités de speaker, contrôler la durée de la session …

Si vous êtes un speaker expérimenté, faites un duo ou parrainez de nouveaux speakers. Vous voulez être speaker ? Etudiez les talks de bons speakers et cherchez un mentor pour vous accompagner. Vous êtes dans une équipe, accueillez les nouveaux, amenez les à votre JUG, parlez aux étudiants.

Malheureusement le nombre de femmes dans l’IT est limité par les nombre de femmes qui ont choisi d’étudier l’informatique.

Les raisons peuvent être profondes et remonter à l’enfance. Apprenez aux enfants, filles et garçons, à être curieux, apprenez leur l’informatique via des jeux, à construire des objets. Inculquez leur l’intérêt pour les sciences et les choses merveilleuses quelle permet de produire

 

Ce sont quelques réflexions sur les sessions women in IT à Devoxx 2011. N’hésitez à me faire part de vos retours via les commentaires.

Trisha Gee a aussi écrit un post sur ces sessions Why We Shouldn’t Target Women. Merci à Trisha pour la relecture de mon article en anglais.

Le post de Tim Bray’s surDevoxx 2011 Geeks Gather in Belgium

Devoxx 2011 and Women

"The absence of women in tech is the elephant in the living room, it must be discussed" – Tim Bray – Conference Day 2 Keynote – Devoxx 2011

Tim Bray started the keynote with this statement and announced the session "Why we shouldn’t target women". Room 3 was full, whereas we had been expecting 20 people. Thanks again to Tim Bray for his vibrant keynote and supporting us so brilliantly.

How many women at Devoxx this year ?

Not many. 1% of Devoxx 2010′s attendees were women. Figure is unavailable at the moment but it seems similar.

More female speakers in proportion this year. Amongst 167 speakers, 9 are female speakers though only 4 gave a technical talk or BOF (Patrycja Wegrzynowicz Performance Anti-pattern in Hibernate, Lilli Thompson Cross platform game programming with PlayN, Birgitta Boeckeler Code generation at large, Sonya Barry BOF lessons from the java.net migration ) and 5 talked at the women BOF and panel ( Regina ten Bruggencate, Trisha Gee,Anna Gos, Kim Ross, Claude Falguiere )

Four speakers is more than last year anyway. Don’t blame the Devoxx organization: few women in IT means few female speakers.

Women are fewer and fewer in IT and Computer Sciences schools. The number decreased from 40% in the 90′s to 20% nowadays. Why? Someone posed the question to the panel. Unfortunately we’re the people who are the least likely to answer this question and we don’t want to make assumptions for others. You may find a lot of theories there http://en.wikipedia.org/wiki/Women_in_computing.

The slope down also affects other scientific jobs to a lesser extent but conversely the number of women in the building industry increases despite the male image of these jobs. Interestingly the number of women in IT is about 50% in emerging countries in Asia, India and Brazil.

Apparently a change is possible. So why we shouldn’t target women ?

First, is it a women issue ? The lack of women is very visible. But other minorities are not there either. How many black speakers ? 1. How many old speakers …

IT experiences a diversity issue. It tends to clone white young men with the same kind of aptitudes.

It’s not only a fairness issue. Diversity is a must for projects. IT projects requires a mix of exploration of new technologies and prudence, a mix of rationalisation, imagination and communication, being in touch with users and ops. IT requires people with different mindsets and career path.

Diversity of people, diversity of jobs

Let’s introduce IT as an industry with a large number of activities ranging from design to hard core programming, to produce a large variety of applications from web site, smartphone application to plane control system. Let’s show different kind of people.

!Geeky image: DONE

What else ?

What about a women in the team because women are good at communicating, visual design or whatever ? These are stereotypes as well. Amongst the panel Kim liked being a mom of the team, others don’t. Not all women like nurturing and caring team members and conversely some men are very good at that. We must consider the human being not the category

So how can we increase diversity ?

Welcome newcomers

Have you ever try to join a group of geeks arguing about the better framework ? It’s intimidating, they all seem so clever. JUGs are good places to get in touch with teams and be aware of interesting jobs. But JUGs, especially the ParisJUG because it’s so large, may be intimidating to new comers.

Welcome newcomers. Help them get into discussions, prepare the meeting with them like the Duchess France does before the ParisJUG, pass information you’ve learnt in previous sessions, promote open-source projects and help them join the community though hackerspace.

Newcomer is a woman ? Great! But don’t forget men also feel new and alone.

Increase confidence

Women often lack of self-confidence. They don’t feel expert enough, they fear they’re bad speakers, they worry about rating themselves too highly. What can we do ? Mentoring, pairing are ways to get started and improve self confidence.

And girls, pluck up your courage and move forward. Talking to 50 people, learning new technologies is uncomfortable for men too. But they never mention it ;-)

Sometime you will fail. You will think about it and improve yourself. And retry.

You will come across guys that proudly state that the female brain is not wired to do Computer Science. You’ve chosen to go for IT because you like this job. Recall all your successful projects. Even if it’s true (I’m not a neurologist) and it’s harder ? So what ! Some of us made it, you will as well.

You will also come across speakers that show offending images like the "Duct Tape talk" at Devoxx 2011 ( http://www.slideshare.net/ertmanb/devoxx-building-nextgeneration-enterprise-applications-in-java ). Don’t feel rejected. Everyone feel it’s inappropriate to show almost naked women in a technical talk. Humor is great around a beer, but not when the target can’t reply.

There are stereotypes around. Be prepared to explain again and again that there are women in IT and show what you can do until there are enough women to break this stereotype.

Parenting

One the things women have to deal with is maternity leave and parenting.

Instead of rejecting women because of maternity, we may adapt this industry to parenting, especially working hours. Antonio explained that men also want to spend more time with their children.

Proactivity for the next generation

The attendees had a lot of questions about proactivity. Should we be proactive when hiring women ? Would there be more women if we gave away free tickets for Devoxx to women ?

Proactivity is often a bad idea. It creates imbalance. Some guys complained about long lines at the men’s room while the women’s were empty. What would they say if the women besides them had a free ticket ?

Moreover quotas may promote unqualified persons in order to reach the quota. Someone posed a question about how to behave with a boss that is a woman and younger than you are. Was she young and a woman or unprepared for this job ?

People learn by experience. Women should have normal career path, learn, become the most qualified person and be promoted because they deserve the job. Same goes for talks. It would be a very bad idea to promote women that never did any talk straight to Devoxx. Lots of talks given by men are bad, but a bad talk given by a women will be more noticeable.

Still want to be proactive ? Prepare the future.

We all want to see new faces in conferences, whether they are women or men. I’ve talked to a lot of JUG Leaders that want to bring more women to their JUGs. JUG Leaders, you have the hard task to promote new speakers and let them know. Ask women around you and men too for talks.

JUGs are a nice place to begin as a speaker because of limited audience and low stake. The talk can be given many time in different areas, giving the opportunity to tweak slides, improve speech capacities, calibrate the talk length …

If you’re an experienced speaker, pair or mentor new speakers. Want to be a speaker ? Look to all the talks you can from good speakers and look for mentoring. You’re a team member, welcome newcomers, bring them to your  JUG, talk to students.

Unfortunately the number of women in IT is limited by the number of women that went for computer sciences.

It takes root in childhood. Teach children, girls and boys, to be curious, to learn programming through games, to build things. Teach them interest in sciences and all the beautiful things science produces.

 

These are reflections about Devoxx 2011′s women in IT sessions. Please feel free to give me your feedback via the comments form.

Trisha Gee also wrote a post about these sessions Why We Shouldn’t Target Women. Thanks Trisha for proofreading my post.

Tim Bray’s post about Devoxx 2011 Geeks Gather in Belgium

Des images en 8-bits pour iOS

Warning: Input PNG does not have an 8 bit input depth

Lors du packaging d’une application, XCode vérifie les caractéristiques des images embarquées avec l’application. En interactif on ne voit rien, mais lorsque l’on scripte les opérations de fabrication, ce type de messages apparaît :

CopyPNGFile build/Release-iphoneos/Ipad.app/interview-frP05-100-2.png Ipad/Images/Interview/Portrait/100/interview-frP05-100-2.png 
libpng warning: Warning: Input PNG does not have an 8 bit input depth. Please convert your PNG to 8-bit for optimal performance on iPhone OS

Si on regarde d’un peu plus près on se rend compte que les images concernées sont toutes du même type.

L’application contient un entretien "PDF" zoomable stocké sous forme d’images 2048×1538. Pour améliorer les performances à l’affichage ces images ont été découpées en tuiles. Au zoom maximal, certaines zones sont assez vides ou monochromes, en particulier les bords d’images.

Les images sont découpées avec ImageMagick. Un examen des images avec warning montre qu’elles n’ont pas les mêmes caractériques que les images qui ne causent pas d’erreur.

Une image sans erreur

identify -verbose Ipad/Images/Interview/Landscape/100/interview-frL02-100-13.png Image: IpadCorporate/Images/Essentiel/Interview/Landscape/100/interview-frL02-100-13.png
  Format: PNG (Portable Network Graphics)
  Class: DirectClass
  Geometry: 256x256+0+0
  Resolution: 72x72
  Print size: 3.55556x3.55556
  Units: Undefined
  Type: TrueColor
  Endianess: Undefined
  Colorspace: RGB
  Depth: 8-bit
  Channel depth:
    red: 8-bit
    green: 8-bit
    blue: 8-bit

L’image la plus à gauche, qui ne contient quasiment que tu texte en gris est en GrayScale 

identify -verbose Ipad/Images/Interview/Portrait/100/interview-frP01-100-1.png Image: IpadCorporate/Images/Essentiel/Interview/Portrait/100/interview-frP01-100-1.png
  Format: PNG (Portable Network Graphics)
  Class: PseudoClass
  Geometry: 256x256+0+0
  Resolution: 72x72
  Print size: 3.55556x3.55556
  Units: Undefined
  Type: Grayscale
  Base type: Grayscale
  Endianess: Undefined
  Colorspace: Gray
  Depth: 8-bit
  Channel depth:
    gray: 8-bit

Certaines autres images sont en Bilevel (Black & White) 

identify -verbose Ipad/Images/Interview/Landscape/100/interview-frL02-100-32.png Image: IpadCorporate/Images/Essentiel/Interview/Landscape/100/interview-frL02-100-32.png
  Format: PNG (Portable Network Graphics)
  Class: PseudoClass
  Geometry: 256x256+0+0
  Resolution: 72x72
  Print size: 3.55556x3.55556
  Units: Undefined
  Type: Bilevel
  Base type: Bilevel
  Endianess: Undefined
  Colorspace: Gray
  Depth: 8/1-bit
  Channel depth:
    gray: 1-bit

ImageMagick cherche le format le plus adapté ce qui revient parfois à transformer l’image en niveaux de gris voir en Noir et Blanc si elle n’a pas de contenu.

Une première solution

J’ai d’abord tenté de forcer la profondeur à 8-bits avec la syntaxe png8:nom-fichier

convert interview-frP01-100.png -crop 256x256 +repage +adjoin png8:interview-frP01-100-%d.png

Cette option supprime bien les warnings mais ne rend pas un très bon résultat. Sur l’image réassemblée, le dégradé sur le fond est remplacé par un effet psychédélique assez laid.

L’image est postérisée car le nombre de couleurs est réduit.

identify -verbose generated_images/Interview/Portrait/100/interview-frP01-100-10.png Image: generated_images/Interview/Portrait/100/interview-frP01-100-10.png
  Format: PNG (Portable Network Graphics)
  Class: PseudoClass
  Geometry: 256x256+0+0
  Resolution: 72x72
  Print size: 3.55556x3.55556
  Units: Undefined
  Type: Palette
  Endianess: Undefined
  Colorspace: RGB
  Depth: 8/4-bit
  Channel depth:
    red: 4-bit
    green: 4-bit
    blue: 4-bit

Ceci dit cette option marche bien sur un autre jeu de tuiles qui ne contient que des images monochromes.

La solution correcte

J’ai ensuite tenté diverses options (-depth, -colorspace, -type, -define png:bit-depth). En fait, CopyPNGFile semble rejeter le colorscale Gray mais je n’ai pas réussi à convaincre ImageMagick de ne pas changer le colorscale des tuiles très simples.

L’issue est dans le pngN: mais il faut lui donner les bonnes valeurs.

Le build veut 8 bits par canal de couleur.

Les images en RGB (Red Green Bleu le color scale le plus courant) comportent 3 canaux :
  • un qui contient la valeur du rouge,
  • un qui contient la valeur du vert (Green)
  • et un qui contient la valeur du bleu.

Chaque pixel est codé sur 8 bits soit une valeur entre 0 et 255. La combinaison de la valeur de chaque canal produit la couleur souhaitée parmi 16 millions de couleurs (256x256x256).

Pour les images transparentes, elles comportent un quatrième canal, le canal alpha, qui indique la transparence du pixel.

Si on veut 8 bits par canal il faut indiquer png24 (3×8) pour une image sans transparence, ou png32 (4×8) pour une image avec un canal alpha.

convert interview-frP01-100.png -crop 256x256 +repage +adjoin png24:interview-frP01-100-%d.png

Cette option supprime les warnings et ne dégrade pas l’image.

L’image de gauche en niveau de gris devient

identify -verbose Ipad/Images/Interview/Portrait/100/interview-frP01-100-1.png Image: IpadCorporate/Images/Essentiel/Interview/Portrait/100/interview-frP01-100-1.png
  Format: PNG (Portable Network Graphics)
  Class: DirectClass
  Geometry: 256x256+0+0
  Resolution: 72x72
  Print size: 3.55556x3.55556
  Units: Undefined
  Type: Grayscale
  Base type: Grayscale
  Endianess: Undefined
  Colorspace: RGB
  Depth: 8-bit
  Channel depth:
    gray: 8-bit

et la plupart des images ressemblent à ce qui suit

identify -verbose Ipad/Images/Interview/Portrait/100/interview-frP01-100-10.png Image: IpadCorporate/Images/Essentiel/Interview/Portrait/100/interview-frP01-100-10.png
  Format: PNG (Portable Network Graphics)
  Class: DirectClass
  Geometry: 256x256+0+0
  Resolution: 72x72
  Print size: 3.55556x3.55556
  Units: Undefined
  Type: TrueColor
  Endianess: Undefined
  Colorspace: RGB
  Depth: 8-bit
  Channel depth:
    red: 8-bit
    green: 8-bit
    blue: 8-bit

Atelier iOS à SoftShake 2011

badge softshake speakerJ’anime un ateliersur la mise en place d’une usine logicielle à SoftShake lundi après midi.Cet atelier montrera comment mettre en place un projet XCode, faire du TDD avec OCUnit, mettre en place le repo Git; faire un makefile, l’intégrer dans Jenkins et déployer Over the Air via une
Si vous voulez pouvoir coder en même temps sur votre machine , voici les pré-requis.Pas de pré-requis pour participer en auditeur.Pour coder et faire du TDD
- Mac OS X 10.6
- XCode 4
- un peu connaître Objective-CPour la partie intégration avec le repo Git et le makefile
- XCode 4 avec les outils en ligne de commande (dev tools ou system tools selon les versions)
- rake avec les gems json et plist (sudo gem install json plist)
- git et gitx
- avoir un compte github ou un autre repo git accessible en lecture
par tous (pour le CI)
- si possible cloner https://github.com/ValtechTechno/ios-software-factoryLe reste de l’usine (Jenkins, Mobile Store) est trop long a mettre en place en atelier. Tous les éléments de l’usine logicielle et des informations de mise en oeuvre sont partagés sur le github de Valtech, team iOS https://github.com/ValtechTechno/ios-software-factory sous licence Apache 2. Les pré-requis sont dans les readme.

La présentation se trouve ici.

 

Le JUG Summer Camp c’est fini pour cette année

Le JUG Summer Camp vient de se terminer. Une journée de conférences intéressantes dans superbe cadre. Au menu du Java, mais on aussi pas mal parlé de Cloud cette année.

Une sélection de quelques sessions auxquelles j’ai assisté.

Lascaux II - Hall of The Bulls

Antonio Goncalves : Keynote d’ouverture

Antonio a retracé l’histoire de l’information dessinée sur des parois grottes en Australie, sur du papier, des cartes perforées, stockées dans des ordinateurs et finalement on ne sais où dans le Cloud par ce qu’il en a trop. Pour que les êtres humains puissent échanger cette information, ils doivent se mettre d’accord sur son sens et les normes apparaissent. De plus en plus d’information, de plus en plus de volume, du Cloud, mais un Cloud sans normes qui met les applications en situation de Cloud Locking. Et Antonio est un homme libre, il n’aime pas le Cloud Locking ;-)

Et Java dans tout ça ? Java sera Cloud (entre autres la liste de toutes ses prédictions a été largement relayée sur Twitter). L’expert group JavaEE se penche sur le sujet. Donc on vous le dit : Java sera Cloud !

Michaël Figuière : Les applications et architectures d’entreprise de demain

Les architectures sont en train de changer depuis quelques années. Michaël nous a livré ses reflexions sur les possibilités nouvelles qu’elles nous offrent.

Arrivée de la mobilité. Les smartphone permettent d’avoir un accès permanent à Internet et possèdent des capteurs qui permettent la détection du mouvement, de la vitesse et une géolocalisation précise. Ces fonctions sont utilisées pour faciliter la vie de l’utilisateur,  ne pas avoir à préciser son adresse lorsque l’on commande un taxi G7, éviter de refaire la même recherche parce que le système a mémorisé la demande et envera une notification s’il y a un changement ou une information utile.

Les informations collectées sur l’utilisateur peuvent aussi être analysées pour sélectionner les services à lui proposer, lui recommander des achats comme sur Amazon. Il s’agit là de filtrer, trier et appliquer des technique proches de l’IA sur d’énormes masses de données. Twitter gère des millions de tweets par jour. Et justement grace au NoSQL et au Cloud on dispose maintenant de bases de données et d’infrastructures qui peuvent monter en puissance.

Des outils qui permettent de traiter ces volumes de données :
Esper est outil d’analyse d’événements temps réel (analyse des actions des utilisateurs, surveillance de système, données de flux financiers …)
Mahout basé sur Hadoop est un outil d’analyse de données basé sur Hadoop (je l’ai déjà traité dans mon post Devoxx 2010).

Ces changements impactent aussi la conception. Ce besoin de temps réel nécessite de mieux gérer la disponibilité. Les applications doivent être plus résiliantes. A l’opposé du design classique qui considère que l’infrastructure marchera et n’a pas de moyens d’action lorsque des sous systèmes qui ne répondent pas ou mal, le Design for failure accepte que le système puisse avoir des défaillances techniques et les gère pour qu’ils aient le moins d’impact possible. De nouveaux mécanismes apparaissent comme les circuit breakers (coupe-circuits).

La présentation

Nicolas De Loof : Ma forge++ : on the cloud

Nicolas est venu nous présenter Cloudbees une plate-forme qui permet d’avoir une forge logicielle et un environnement d’exécution Java de test ou de production dans le Cloud.

Nicolas reprend la forge idéale qu’il nous avait présenté l’an dernier (Maven, jenkins …). Elle est efficace mais il y a beaucoup de composants à installer pour chaque projet. Comment faire ? Cloner ? Automatiser l’installation ? Ou bien utiliser une forge toute prête en SAAS comme  DEV@cloud.

Mathieu Ancelin : Weld-OSGi, OSGi en toute simplicité

Weld est l’implémentation de référence de CDI (Context and Dependency Injection), la spécification  Java™ Specification Request (JSR) 299. L’injection de dépendance permet de créer dynamiquement (injecter) les dépendances entre les différentes classes en s’appuyant sur une description par des annotations ou un fichier de configuration). Cette technique permet par exemple de choisir une implémentation particulière d’une interface lors de l’exécution. Si vous avez besoin d’une mise à niveau vous pouvez regarder le tutorial d’Antonio Goncalves sur CDI.

OSGI est une spécification gérée par un consortium d’entreprises qui permet de réaliser des applications modulaires orientées service. Elle repose sur un modèle de gestion du cycle de vie d’une application, un répertoire de services, un environnement d’exécution et des modules (les services). L’usage typique est de choisir de dépployer dynamiquement des services dans un serveur et de sélectionner à l’exécution les services que l’application doit proposer. OSGI permet d’identifier les dépendances entre modules et les versions.

Mathieu Ancelin nous a fait une présentation très claire d’OSGI (ce qui n’est pas simple). Il nous a ensuite un peu plus parlé de Weld-OSGI.

Weld-OSGI est un projet Open Source dont l’objectif est de régler quelques problèmes techniques d’intégration entre les deux mondes et de fournir une API plus simple de manipulation des services OSGI. L’intégration permet de découvrir dynamiquement des services OSGI. Concrètement ces modules sont des jar et sont chargés dynamiquement dans le class loader. CDI permet ensuite d’injecter une classe de ce module dans la classe qui utilise le service.

Mathieu a fait une démo assez bluffante d’application Web de réservation d’hôtel (JAX-RSJQuery) où il modifie dynamiquement les services présentés en arrêtant/démarrant les modules. Et tout ça avec une centaine de lignes de code.

Romain Maton : Optimiser votre site Web sur mobile

Romain a fait un tour d’horizon très complet des contraintes techniques du Web Mobile et des outils qui peuvent nous aider. La présentation est très dense et contient beaucoup d’informations techniques. Elle sera mise à disposition sur Web Tambouille et sur le site du JUG Summer Camp.

En résumé très rapide, les smartphones  disposent de peu de mémoire, peu de CPU et peu de bande passante réseau. C’est au développeur de faire attention pour que le site soit agréable à utiliser. Il doit faire attention aux aspects techniques (optimisation du HTML, du CSS, des images et être parcimonieux avec le JavaScript). Comme on est très loin des capacités disponibles sur les sites Web classiques, il va falloir choisir, recentrer l’application sur sa fonction centrale, éliminer les fonctions qui ne sont pas utilisées sur un mobile. Des validateurs de code et des outils d’analyse des pages permettent de corriger les erreurs de codage ou de configuration des caches.

Nicolas Martignole : Keynote de fermeture

La présentation de Nicolas est impossible à raconter. Il faudra aller la voir en vidéo. Il se projète en 2021 et nous présente une émission "10 ans après" sur le métier de développeur. L’occasion de parler avec beaucoup d’humour de la situation actuelle.

logo jugsummercamp

Les présentations et les vidéos seront bientôt disponibles sur Parleys et le site du JUG Summer Camp.

Merci au Poitou-Charentes Java User Group et à Serli pour l’organisation et à l’année prochaine, on l’espère.