C’est la première fois que je ne trouve pas un gem Ruby qui correspond a mes besoins. C’est une bonne occasion pour en proposer un. Il s’agit d’utiliser l’API Google Maps Geocoding Service en Ruby.

Le gem gmaps_geocoding est la réponse a mon problème. Ce gem, minimaliste, permet d’utiliser pleinement le service web Google Maps Geocoding Service.

# json output example (default output)
opts = {address: 'Tour Eiffel, Paris, IDF, France', output: 'json'}
api = GmapsGeocoding::Api.new(opts)
result = api.get_location

# xml output example
opts = {address: 'Tour Eiffel, Paris, IDF, France', output: 'xml'}
api = GmapsGeocoding::Api.new(opts)
result = api.get_location

Très simplement.

Liens :

• sur rubygems.org
• sur github

Linux offre une interface pour récupérer toutes les trames USB.
le module kernel s’appelle USBMON, pour l’intégrer dans le kernel, exécuter la ligne ci-dessous :

sudo modprobe usbmon

Installer ensuite un outil pour filtrer graphiquement le dialogue USB, pour ma part Wireshark fais très bien l’affaire :

sudo apt-get install wireshark

Vérifier si debugfs est monté sur la machine :

sudo ls -l /sys/kernel/debug

Si ce n’est pas le cas, montez-le avec la commande suivante :

sudo mount -t debugfs / /sys/kernel/debug

Lancer Wireshark en tant root et sélectionner le bus USB souhaité :

sudo wireshark

Voilà, à vous le debug USB sous linux, très simplement.

C++11 offre une abstraction simple pour gérer le temps. Le tout est inclus dans le header <chrono>.
Avec cette nouvelle manière de représenter une période, il est facile de convertir les types de durée :

• nanosecondes (std::chrono::nanoseconds)
• microsecondes (std::chrono::microseconds)
• millisecondes (std::chrono::milliseconds)
• secondes (std::chrono::seconds)
• minutes (std::chrono::minutes)
• heures (std::chrono::hours)

Avant de commencer définissons les 3 types d’horloges qu’il nous ait possible d’utiliser :

std::chrono::system_clock

Représente l’horloge système. Celle qui peut être modifiée à tout moment. Cette horloge permet généralement l’affichage de la date sur un système.

std::chrono::steady_clock

Horloge monotonique, certainement la plus adaptée pour représenter une période. Cette horloge ne diminue pas au fur et à mesure que le temps avance et n’est pas liée à l’horloge système. Elle assure une cadence fiable.

std::chrono::high_resolution_clock

L’horloge la plus précise disponible sur l’environnement d’exécution. Peut représenter l’horloge système, l’horloge monotonique ou une autre horloge mais dans tous les cas, la plus précise.

Maintenant que nous connaissons les possibilités pour récupérer un instant temporel, tentons de réaliser un exemple simple (G++ 4.7.x minimum) :

#include<iostream>
#include<chrono>
#include<thread>

int main () {
    auto start = std::chrono::steady_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(2));
    auto end = std::chrono::steady_clock::now();
    auto elapsed = end - start;
    std::cout << " Elapsed time: " << elapsed.count() << std::endl;
    std::cout << std::endl;
    return 0;
}

[OUTPUT] Elapsed time: 2000069

Dans cet exemple nous récupérons un instant temporel start, puis réalisons une attente de 2 secondes et reprenons un instant temporel end. Notons que std::chrono:steady_clock::now() renvoi un objet de type std::chrono::time_point. On assigne la différence entre end et start dans la variable elapsed.
elapsed est de type std::chrono::duration, on affiche la durée avec la méthode std::chrono::duration.count(). C’est très claire et sympa à lire. Notons aussi que nous n’avons pas précisé l’unité de la période souhaité, dans ce cas précis nous avons des microsecondes.

Ci-dessous le même exemple en précisant que nous voulons des secondes (G++ 4.7.x minimum) :

#include<iostream>
#include<chrono>
#include<thread>

int main () {
    auto start = std::chrono::steady_clock::now();
    std::this_thread::sleep_for(std::chrono::seconds(2));
    auto end = std::chrono::steady_clock::now();
    auto elapsed = end - start;
    std::cout << " Elapsed time: " << std::chrono::duration_cast<std::chrono::seconds>(elapsed).count() << " seconds" << std::endl;
    std::cout << std::endl;
    return 0;
}

[OUTPUT] Elapsed time: 2 seconds

Une abstraction efficace qui permet une utilisation simple et intuitive des durées.
C’est exactement ce à quoi on s’attend d’une librairie standard.

On continue l’aventure Cplusplus11 après le premier article qui était plus une mise en jambe. Cette fois-ci nous allons attaquer les fonctions anonymes, Lambda expression. Les expressions lambda sont utiles pour écrire des blocs de code en ligne qui sont des fonctions un peu spéciales. Ces fonctions anonymes peuvent être passées en paramètre d’autres fonctions et peuvent aussi récupérer le contexte comme nous le verrons plus loin. Par ailleurs les fonctions lambda améliorent aussi la lisibilité des programmes C++11 car il n’est plus nécessaire d’encapsuler des méthodes qu’on veut utiliser qu’une fois dans des classes ou des fichiers externes. C’est maintenant l’heure d’explorer la signature des Lambda expression.

Signature d’une expression lambda

[capture] (arguments) attribute-specifier mutable exception-specification -> return-type {body}
// or
[capture] (arguments) -> return-type {body}
// or
[capture] (arguments) {body}
// or
[capture] {body}

Description de la signature de l’expression lambda

capture (liste de capture)

• [] : aucune capture des variables du contexte
• [this] : capture le pointeur this de la classe englobante
• [&] : capture toutes les variables du contexte par référence
• [=] : capture toutes les variables du contexte par valeur
• [&x] : capture uniquement la variable x par référence
• [x] : capture uniquement la variable x par par valeur
• [x, &y] : capture la variable x par par valeur et y par référence

arguments (liste d’arguments)

• liste des paramètres de la fonction lambda

attribute-specifier, mutable, exception-specification (modificateur et spécificateurs)

• attribute-specifier : [[noreturn]] indique que la fonction ne retourne rien et [[carries_dependency]] permet de contrôler la gestion du stockage en mémoire. Ne fonctionne pas avec G++ 4.6.3, actuellement seul Intel-C++ 12.1 les supportes
• mutable : permet de modifier les variables capturées par valeur dans le corps de la fonction
• exception-specification : spécificateur d’exception tel que noexcept, throw(), etc…

return-type

Type de retour de la fonction lambda.

body

Corps de la fonction lambda.

Exemple d’utilisation (projet github des exemples)

#include<iostream>
#include<vector>
#include<algorithm>

int main() {
	std::vector<std::string> data{"first", "second", "third"};
	std::string one = "one!!";
	std::string two = "two";
	std::string three = "three";
	std::cout << std::endl;
	// Process data vector with lambda function
	for_each(begin(data), end(data), [one, &two, &three](std::string &item) mutable {
		item  += "_append";
		one   += "_another value now"; // We use "mutable" for variable passed by copy.
		two   += "_two";
		three += "_three";
	});
	// Print data vector after processing
	std::cout << "after:" << std::endl << " - data: ";
	for (const auto d : data) {
		std::cout << d << " ";
	}
	std::cout << std::endl;
	std::cout << " - one: " << one << " - two: " << two << " - three: " << three;
	std::cout << std::endl;
	return 0;
}

Dans cet exemple nous initialisons un vecteur de string avec 3 éléments, puis nous initialisons 3 variables de type string. Nous utilisons for_each pour parcourir le vecteur data et concaténons chaque élément avec une expression lambda passée en paramètre de for_each. Dans le corps de la fonction lambda, nous concaténons aussi les variables one (récupéré par valeur), two (récupéré par référence), three (récupéré par référence). Nous affichons, au final, le résultat. Vous remarquerez que la variable one n’a pas été impactée après le traitement car elle a été capturée par valeur.

//output
after:
 - data: first_append second_append third_append
 - one: one!! - two: two_two_two_two - three: three_three_three_three

Ce sera tout pour le moment, nous attaquerons d’autres nouveautés dans un prochain article…

Je viens de recevoir mon boîtier Pibow après 1 mois et demi d’attente. Mais ce n’est qu’une étape avant de recevoir le device Raspberry Pi le mois prochain. Un conseil, soyez patient !

Photos du déballage :

Il y a quelques mois je me réjouissais de la validation du standard C++11. Je regrette toujours que les sockets réseau n’aient pas été implémenté.

Après plusieurs lectures sur le sujet, je recherche l’adoption totale de la nouvelle syntaxe de C++11. Tentons de dompter les nouveautés. Les exemples sont testés avec GCC version 4.6.1 (Ubuntu/Linaro 4.6.1-9ubuntu3), le code source est disponible sur GitHub.

Nous allons commencer à travailler sur les types automatiques avec le mot clé auto et l’opérateur decltype.

#include<iostream>
#include<vector>
#include<string>
#include<algorithm>//for_each
#include<typeinfo>//typeid

int main() {
  std::vector<std::string> data{"first", "second", "third"};//uniform brace notation
  for (const auto item : data) {//Range based for loop
  std::cout << "Iterate =>" << std::endl;
    std::cout << "  Automatic item type: " << typeid(item).name() << " - Item value: " << item << std::endl;
    decltype(item) dynamic_value = item;
    std::cout << "  Dynamic type: " << typeid(dynamic_value).name() << " - Dynamic value: " << dynamic_value << std::endl;
    std::cout << std::endl;
  }
  return 0;
}

Dans cet exemple nous initialisons un vecteur de chaîne de caractères puis bouclons sur chaque item ; le type de chaque item est récupéré automatiquement et nous créons dynamiquement une variable du même type que l’item. Pour le moment ne tenez pas compte de la syntaxe particulière de la boucle for.

Simplification de l’itération simple d’un conteneur avec la structure de contrôle for.

#include<iostream>
#include<vector>
#include<string>

int main() {
  std::vector<std::string> data{"first", "second", "third"};
  for(const auto item : data) {
    std::cout << "Item value: " << item << std::endl;
  }  
  return 0;
}

Une simple boucle for tel que le propose déjà des langages tel que Java ou C#. Un vrai bonheur pour notre langage. Notons que pour un parcours spécifique ou plus complexe, il est plus puissant d’utiliser for_each ; par exemple commencer l’itération à partir du 3^ème élément.

Avant C++11, la macro NULL équivalente à 0, est parfois considéré comme très particulière par les développeurs et porte à confusion. C++11 propose une expression nullptr, plus d’excuses et arrêtons d’utiliser 0 ou NULL pour initialiser un pointeur.

#include<iostream>
#include<vector>

int main() {
  const int* p = nullptr;
  std::vector<int> data{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
  for (const auto item : data) {
    p = &item;
    std::cout << "Item pointer: " << *p << std::endl;
  }
  return 0;
}

On initialise un pointeur avec nullptr et non 0, puis on boucle sur les données en assignant l’adresse de chaque item au pointeur p.

Uniformisation de l’initialisation avec les accolades {}. Avant C++11, selon qu’on veut initialiser un tableau, les membres d’une structures… avec des zéros ou avec des valeurs différentes de zéro, il fallait passer par des syntaxes différentes. Avec C++11 on arrête avec toutes ces possibilités, on uni formalise comme le montre le code source suivant :

#include<string>
#include<sstream>
#include<vector>

struct Version {
  uint32_t major;
  uint32_t minor;
  uint32_t revision;
  
  std::string toString() const {
    std::ostringstream oss;
    oss << major << "." << minor << "." << revision;
    return oss.str();
  }
};

int main() {
  Version v{0, 1, 0};//Constructor initialization
  std::cout << "Version v{0, 1, 0}: " << std::endl;
  std::cout << "  " << v.toString() << std::endl;
  std::vector<Version> vArray{{0, 1, 0}, {0, 1, 1}, {0, 1, 2}};//Array initialization
  std::cout << "std::vector<Version> vArray{{0, 1, 0}, {0, 1, 1}, {0, 1, 2}}: " << std::endl;
  for (const auto v : vArray) {
    std::cout << "  " << v.toString() << std::endl;
  }
  return 0;
}

On crée une instance de Version en initialisant major, minor et revision. On crée ensuite un vecteur de Version en initialisant les 3 premiers éléments.

Les nombres aléatoires, peuvent être générés selon un nouveau modèle qui se compose de deux éléments, un moteur de génération de nombre (il y en a plusieurs au choix) et une distribution soit une plage de nombre pouvant être généré, là encore on a le choix de la distribution ; voir un aperçu via ce lien.

#include<iostream>
#include<random>//std::mt19937, std::uniform_int_distribution
#include<functional>//std::bind
#include<ctime>

std::mt19937 engine;
std::uniform_int_distribution<uint32_t> distribution{1, 10};

int main() {
  engine.seed(static_cast<uint32_t>(std::time(nullptr)));
  auto generator = std::bind(distribution, engine);
  uint32_t random = generator();
  std::cout << "1st random: " << random << std::endl;
  random = generator();
  std::cout << "2nd random: " << random << std::endl;
  return 0;
}

Dans cet exemple on instancie le moteur de génération de type Mersenne Twister avec une distribution uniforme d’entier. On initialise dans la méthode main, le moteur avec un nombre entier récupérer de l’horloge de la machine. On se fabrique une fonction generator qui permet d’appeler notre générateur avec un nom plus intuitif.

Voilà c’est une première mise en jambe avec C++11 histoire de s’échauffer. Je reste persuadé du potentiel de ce langage et de son avenir glorieux. C++11 est le langage le plus concis et rapide de la planète.

J’ai acheté il y a 4 mois le smartphone Google Nexus chez Rue du Commerce, mais depuis, et je ne sais pas pourquoi, à chaque annonce de mise à jour d’Android Ice Cream Sandwich, impossible que la détection des mises à jour me propose quoique ce soit…

Finalement ce matin j’ai décidé de réaliser manuellement cette mise à jour via les outils et fichiers officiels de Google (Pas besoin de rooter le téléphone).

La première chose à faire est d’installer le SDK Android via le lien suivant (pour les connaisseurs, uniquement le binaire fastboot est suffisant) : http://developer.android.com/sdk/installing.html.

Vérifier la configuration USB du Google Nexus sur la machine en vérifiant ou créant le fichier des droits udev (seules les lignes des Google Nexus sont nécessaires mais qui sait, j’aurai peut-être le bonheur de tester d’autres Google Android devices)

chris@tux:~/tmp/yakju-imm76i$ sudo emacs /etc/udev/rules.d/51-android.rules

Copier/coller les lignes suivantes dans le fichier /etc/udev/rules.d/51-android.rules

# adb protocol on passion (Nexus One)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e12", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# fastboot protocol on passion (Nexus One)
SUBSYSTEM=="usb", ATTR{idVendor}=="0bb4", ATTR{idProduct}=="0fff", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# adb protocol on crespo/crespo4g (Nexus S)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e22", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# fastboot protocol on crespo/crespo4g (Nexus S)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e20", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# adb protocol on stingray/wingray (Xoom)
SUBSYSTEM=="usb", ATTR{idVendor}=="22b8", ATTR{idProduct}=="70a9", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# fastboot protocol on stingray/wingray (Xoom)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="708c", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# adb protocol on maguro/toro (Galaxy Nexus)
SUBSYSTEM=="usb", ATTR{idVendor}=="04e8", ATTR{idProduct}=="6860", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# fastboot protocol on maguro/toro (Galaxy Nexus)
SUBSYSTEM=="usb", ATTR{idVendor}=="18d1", ATTR{idProduct}=="4e30", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# adb protocol on panda (PandaBoard)
SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d101", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# fastboot protocol on panda (PandaBoard)
SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d022", MODE="0600", OWNER="##votre_nom_d_utilisateur##"
# usbboot protocol on panda (PandaBoard)
SUBSYSTEM=="usb", ATTR{idVendor}=="0451", ATTR{idProduct}=="d010", MODE="0600", OWNER="##votre_nom_d_utilisateur##"

On relance le service udev

chris@tux:~/tmp/yakju-imm76i$ sudo service udev restart

Télécharger et décompresser la mise à jour Factory Images « yakju » for Galaxy Nexus « maguro » (GSM/HSPA+) (pas besoin de Google Wallet en France pour la majorité d’entre nous) depuis le site de Google : https://developers.google.com/android/nexus/images?hl=fr-FR#yakju

Démarrer le Google Nexus en mode fastboot en appuyant simultanément sur les boutons : Volume+ et Volume- et PowerOnOff

Se rendre dans le répertoire où l’image à été décompressé pour débloquer le mode fastboot

chris@tux:~/tmp/yakju-imm76i$ fastboot oem unlock
...
OKAY [ 25.900s]
finished. total time: 25.900s

Lancer la mise à complète d’ICS 4.0.4

chris@tux:~/tmp/yakju-imm76i$ ./flash-all.sh
sending 'bootloader' (2308 KB)...
OKAY [  0.318s]
writing 'bootloader'...
OKAY [  0.292s]
finished. total time: 0.610s
rebooting into bootloader...
OKAY [  0.006s]
finished. total time: 0.006s
sending 'radio' (12288 KB)...
OKAY [  1.736s]
writing 'radio'...
OKAY [  1.379s]
finished. total time: 3.116s
rebooting into bootloader...
OKAY [  0.006s]
finished. total time: 0.007s
archive does not contain 'boot.sig'
archive does not contain 'recovery.sig'
archive does not contain 'system.sig'
--------------------------------------------
Bootloader Version...: PRIMELA03
Baseband Version.....: I9250XXLA2
Serial Number........: 0146B0000101601D
--------------------------------------------
checking product...
OKAY [  0.007s]
checking version-bootloader...
OKAY [  0.008s]
checking version-baseband...
OKAY [  0.008s]
sending 'boot' (4148 KB)...
OKAY [  0.577s]
writing 'boot'...
OKAY [  0.252s]
sending 'recovery' (4478 KB)...
OKAY [  0.638s]
writing 'recovery'...
OKAY [  0.310s]
sending 'system' (316111 KB)...
OKAY [ 44.125s]
writing 'system'...
OKAY [ 33.302s]
erasing 'userdata'...
OKAY [  0.315s]
erasing 'cache'...
OKAY [  0.013s]
rebooting...

finished. total time: 79.598s

Rebooter en mode fastboot pour remettre le lock par soucis de sécurité

chris@tux:~/tmp/yakju-imm76i$ fastboot oem lock
...
OKAY [  0.170s]
finished. total time: 0.170s

Je suis enfin à jour et je gagne en performance, c’est fluide !!!

Avec Ubuntu Oneiric (11.10), impossible d’installer l’application de téléchargement des mp3s d’Amazon (Amazon MP3 Downloader).
Pour cause les librairies libboost sont trop récentes et ne sont pas retrouveés dynamiquement par le programme AmazonMP3 Downloader ; je crois qu’il vaut mieux pour amazon travailler sur la compilation statique du produit. Ci-dessous les étapes pour pallier le problème (basées sur une discussion ubuntuforums) :

mkdir -p $HOME/tmp/amazonmp3_oneiric
cd $HOME/tmp/amazonmp3_oneiric

Télécharger les fichier .deb :

wget https://launchpadlibrarian.net/26959932/libboost-signals1.34.1_1.34.1-16ubuntu1_i386.deb https://launchpadlibrarian.net/26959936/libboost-thread1.34.1_1.34.1-16ubuntu1_i386.deb https://launchpadlibrarian.net/26959922/libboost-iostreams1.34.1_1.34.1-16ubuntu1_i386.deb https://launchpadlibrarian.net/26959918/libboost-filesystem1.34.1_1.34.1-16ubuntu1_i386.deb https://launchpadlibrarian.net/26959916/libboost-date-time1.34.1_1.34.1-16ubuntu1_i386.deb https://launchpadlibrarian.net/26959928/libboost-regex1.34.1_1.34.1-16ubuntu1_i386.deb https://launchpadlibrarian.net/34165098/libicu40_4.0.1-2ubuntu2_i386.deb
sudo dpkg -i lib*.deb

Télécharger et installer l’application Amazon MP3 Downloader : http://www.amazon.com/gp/dmusic/help/amd.html?ie=UTF8&forceos=Linux.
Pour l’installation, il est possible d’utiliser les détails fournis par amazon sur la page de téléchargement ou en mode console :

sudo dpkg -i AmazonMP3DownloaderInstall.deb

Et voilà.

Discussions qui traitent aussi du sujet :

• http://threebrothers.org/brendan/blog/amazon-mp3-downloader-on-64-bit-ubuntu-lucid-lynx/
• http://www.dom-web.net/?p=1512

J’ai récemment commencé à utiliser RVM, le gestionnaire des versions de ruby, sur mon compte mutualisé Dreamhost. En réinstallant mes gems j’ai été confronté à une erreur concernant la compilation d’ImageMagick nécessaire au gem rmagick. En effet la librairie RMagick2.so n’est trouvée car systématique recherchée dans /usr/local/lib.
Type d’erreur :

LoadError: libMagickCore.so.2: cannot open shared object file: No such file or directory - $HOME/.rvm/gems/ruby-1.8.7-head@monprojet/gems/rmagick-2.13.1/lib/RMagick2.so

L’astuce est de compiler ImageMagick en précisant au compilateur où trouver les librairies compilées et installées par mes soins.
Ci-dessous la ligende commande qui permet à la librarie de s’installer et rechercher où il faut les dépendances :

LDFLAGS="-L$HOME/opt/lib -Wl,-rpath,$HOME/opt/lib"
LD_LIBRARY_PATH=/home/congopro/opt/lib
./configure --prefix=/home/congopro/opt --with-gslib --with-gs-font-dir=/usr/share/fonts/type1/gsfonts/ --without-perl --without-magick-plus-plus

J’ai par la même occasion complétée la procédure de compilation disponible sur le wiki de Dreamhost : http://wiki.dreamhost.com/Image_Magick#Compiling_ImageMagick_on_your_DreamHost_account

C’est hier, samedi 18 juin 2011 que se déroulait la Nuit du Hack 2011. 22 heures et 30 minutes de conférences et ateliers axés sur les techniques de hacking même non numériques tels que le crochetage de serrures…

Je vous invite à aller sur le site de la Nuit du Hack pour connaître le détail du programme et vous faire une idée des sujets de hacking du moment.

Personnellement j’ai du quitter cet évènement dimanche vers 1h00 du matin car je devais courir aux 10km L’Équipe à Paris (couru en 00:51:47, je visais 00:48:00)…

Les ateliers ainsi que le concours de hacking ont débuté avec des sujets très intéressants et passionnants :

• Concours de hacking de type capture de flag : attaques d’ennemis et défenses de son réseau
• Etude d’un test d’intrusion via Metasploit
• Electronique programmable et systèmes libres
• Atelier d’initiation à la cryptographie et l’utilisation des GPUs
• Initiation ARM pour plateforme mobile
• Crochetage basique, serrure haut sécurité, Impression
• etc…

Il est temps de faire le ménage sur les libs installées depuis quelques années chez mon hébergeur : DreamHost.
L’un des composants majeur que j’utilise et qui n’est pas disponible par l’hébergeur est Xapian. Actuellement la version 1.2.5 est stable, mettons à jour notre ancienne version 1.0.23.

Pour rappel Xapian est une librairie de recherche plein texte open source écrite en C++.

Premièrement sur les environnement de Dreamhost, les packages de développement de la librairie UUID ne sont pas disponible, faisons une installation locale.

Récupérer la lib UUID du projet e2fsprogs avec l’une des urls suivantes :

• git://git.kernel.org/pub/scm/fs/ext2/e2fsprogs.git
• http://git.kernel.org/pub/scm/fs/ext2/e2fsprogs.git
• https://git.kernel.org/pub/scm/fs/ext2/e2fsprogs.git

cd $HOME
mkdir -p $HOME/opt/src
cd $HOME/opt/src
git clone git://git.kernel.org/pub/scm/fs/ext2/e2fsprogs.git
cd e2fsprogs
./configure CFLAGS=-fPIC --prefix=$HOME/opt
cd lib/uuid
make && make install

Récupérons les sources de xapian-core puis installons :

cd $HOME/opt/src
wget http://oligarchy.co.uk/xapian/1.2.5/xapian-core-1.2.5.tar.gz
tar -zxvf xapian-core-1.2.5.tar.gz
cd xapian-core-1.2.5
./configure LDFLAGS=-L$HOME/opt/lib CFLAGS=-fPIC CXXFLAGS=-I$HOME/opt/include --prefix=$HOME/opt
make && make install

Récupérons les sources de xapian-bindings puis installons la version pour Ruby :

cd $HOME/opt/src
wget http://oligarchy.co.uk/xapian/1.2.5/xapian-bindings-1.2.5.tar.gz
tar -zxvf xapian-bindings-1.2.5.tar.gz
cd xapian-bindings-1.2.5
./configure --with-ruby LDFLAGS=-L$HOME/opt/lib CFLAGS=-fPIC CXXFLAGS=-I$HOME/opt/include --prefix=$HOME/opt RUBY_LIB=$HOME/opt/ruby_modules RUBY_LIB_ARCH=$HOME/opt/ruby_modules XAPIAN_CONFIG=$HOME/opt/bin/xapian-config
make && make install

Dans l’application RubyOnRails indiquons le chemin de nos modules installés localement (config/environnement.rb) :

if ENV['RAILS_ENV'] == "production"
    config.load_paths += [ ENV['HOME'] + '/opt/ruby_modules' ]
end

J’ai dernièrement écris un billet sur le netbook Asus EeePC 1201HA dans lequel je critiquais le travail d’Intel (certes un rachat) sur l’architecture GMA 500 soit les drivers linux poulsbo, tout pas beau…

Actuellement on peut voir que dans les nouveautés du noyau linux 2.6.37 le driver poulsbo (Intel GMA 500) est présent grâce au travail de Lee Chun-Yi de Novell. Mais ça reste un début seulement car ce pilote ne semble gérer nativement que le rétro-éclairage de l’écran.

Intel, quant à lui, semble au courant du problème mais ne priorise pas sa résolution. C’est dommage pour ceux qui ont hérité de ce GMA 500.

Le motif de conception Singleton est l’un des plus simple a maîtriser. Mais lorsqu’il s’agit d’accès concurrentiel dans un programme, les implémentations classiques ne suffisent plus. Il faut garder à l’esprit que les architectures multiprocesseurs ont plusieurs caches souvent asynchrones « write-back » par opposition à « write-through » pour synchrone (rare car moins performant).

Un singleton moderne devrait implémenter les notions suivantes :

• Double-Checked Locking, double contrôle
• Mutex, accès exclusif
• Memory barrier, Clôture de mémoire à la compilation (intègre parfois la synchronisation au niveau du matériel)
• LFENCE/MFENCE/SFENCE, Synchronise la mémoire matériel

Qu’est ce qu’un Singleton ? En programmation un Singleton est un objet dont on veut garantir qu’une seule instance vit pendant l’exécution du programme. Imaginez un système d’exploitation qui aurait deux instances de son système de fichier !!! C’est le boxon assuré.

Voici mon implémentation en cplusplus (code source d’exemple) :

//singleton.h
#ifndef __SINGLETON_H_
#define __SINGLETON_H_

#include <cstdlib> //std::atexit()

#define MFENCE			"memory_fence"
#define MUTEX_LOCK		"lock"
#define MUTEX_UNLOCK	"unlock"
#define MEMORY_READWRITE_BARRIER	"memory_barrier"

template <typename T>
class Singleton
{
public:
	static T& instance()
	{
		return *get_instance();
	}

	static const T& const_instance()
	{
		return *get_instance();
	}

	static void destroy()
	{
		MFENCE; //On s'assure que tous les caches processeurs sont à niveau
		if (pInstance_ != 0)
			delete pInstance_;
	}

protected:
	Singleton(){}
	~Singleton()
	{
		pInstance_ = 0;
		created_ = false;
	}

private:
	static T* pInstance_;
	static volatile bool created_;
	Singleton(const Singleton &);
	Singleton& operator= (const Singleton &);

	static T* get_instance()
	{
		if (created_ == false)
		{
			MUTEX_LOCK; //On s'assure qu'un seul thread a la main
			if (pInstance_ == 0)
			{
				pInstance_ = new T();
				std::atexit(Singleton::destroy);
			}
			MUTEX_UNLOCK;
			MEMORY_READWRITE_BARRIER; //On s'assure que le compilateur ne change pas l'ordre de ces 2 instructions
			created_ = true;
			MFENCE; //On s'assure que tous les caches processeurs sont à niveau
		}
		return pInstance_;
	}
};

template<typename T> T* Singleton<T>::pInstance_ = 0;
template<typename T> volatile bool Singleton<T>::created_ = false;

#endif//!__SINGLETON_H_

Notons que pour les mutexes, les meilleures implémentations permettent aussi, en plus d’être dans une zone synchrone, de réaliser l’équilant de [SLM]FENCE (PIII : SFENCE – P4 : LFENCE, MFENCE). Pour ce qui est de l’annulation de l’ordre des instructions par le compilateur, je ne vois rien d’autres que d’utiliser une librairie qui fournit des MACROS adaptés aux différents compilateurs et plateformes.

Cette année 2010 est passée à une vitesse telle que je n’ai pas testé grand chose…

Néanmoins dans mes nouvelles résolutions pour 2011 :

• C++0X
• Go (Google)
• Ruby (Rails 3)
• Python 3
• Java (GWT 2)

Meilleurs vœux 2011 !!!

Sous Jaunty Jackalope (9.04) il était facile d’installer les drivers de l’imprimante Canon MP540 récupéré directement du site de Canon. Depuis Karmic Koala (9.10), la libcupsys2 devient libcups2 ; il est devenu impossible d’installer ces drivers puisque Canon n’a pas mis à jours ses packages (04/2008). Ce tutoriel est basé sur la version allemande de Vitali Henrichs.

Toutefois il reste encore une solution, récupérer les modifications que j’ai faîtes ou réaliser les modifications vous-même en suivant les étapes suivantes.

Fichiers à jour : cnijfilter-common_3.00-1_i386.deb, cnijfilter-mp540series_3.00-1_i386.deb.

Télécharger et décompresser les drivers depuis le site de Canon :

mkdir MP540_debian_driver
tar xvf MP540_debian_drivers.tar -C MP540_debian_driver
cd MP540_debian_driver
tar xvf MP540_debian_printer.tar
tar xvf MP540_debian_scangear.tar

Nous devons modifier les fichiers de contrôle des packages Canon pour déclarer libcups2 à la place libcupsys2.

Commençons par le packge cnijfilter-common_3.00-1_i386.deb :

dpkg-deb -x cnijfilter-common_3.00-1_i386.deb common
dpkg-deb --control cnijfilter-common_3.00-1_i386.deb
vim DEBIAN/control

Remplacer la ligne :

Depends: libc6 (>= 2.3.4-1), libcupsys2 (>= 1.2.1), libpopt0 (>= 1.7)

Par :

Depends: libc6 (>= 2.3.4-1), libcups2 (>= 1.2.1), libpopt0 (>= 1.7)

Copions nos modifications dans le répertoire « common » et reconstruisons le package :

cp -a DEBIAN/ common/
dpkg -b common cnijfilter-common_3.00-1_i386.deb

Installons l’archive modifiée :

sudo dpkg -i --force-architecture cnijfilter-common_3.00-1_i386.deb
rm -rf common DEBIAN

Modifions le package cnijfilter-mp540series_3.00-1_i386.deb :

dpkg-deb -x cnijfilter-mp540series_3.00-1_i386.deb mp540series
dpkg-deb --control cnijfilter-mp540series_3.00-1_i386.deb
vim DEBIAN/control

Remplacer la ligne :

Depends: libatk1.0-0 (>= 1.9.0), libc6 (>= 2.3.4-1), libcairo2 (>= 1.0.2-2), libcupsys2 (>= 1.2.1), ...

Par :

Depends: libatk1.0-0 (>= 1.9.0), libc6 (>= 2.3.4-1), libcairo2 (>= 1.0.2-2), libcups2 (>= 1.2.1), ...

Copions nos modifications dans le répertoire « mp540series » et reconstruisons le package :

cp -a DEBIAN/ mp540series/
dpkg -b mp540series cnijfilter-mp540series_3.00-1_i386.deb

Installons l’archive modifiée :

sudo dpkg -i --force-architecture cnijfilter-mp540series_3.00-1_i386.deb
rm -rf mp540series DEBIAN

Installons les drivers pour la fonction scanner :

sudo dpkg -i --force-architecture scangearmp-common_1.20-1_i386.deb
sudo dpkg -i --force-architecture scangearmp-mp540series_1.20-1_i386.deb

Modifions les droits du fichier « /usr/lib/cups/filter/pstocanonij » qui n’appartiennent pas à « root » après l’installation et redémarrons cups :

sudo chown root:root /usr/lib/cups/filter/pstocanonij
sudo service cups restart

Pour accéder aux options avancées de l’imprimante vous pouvez récupérer le fichier ppd depuis le site de Vitali :

wget http://www.viilinux.de/viilinux_wp-content_EF65lgN/uploads/2010/08/MP540-series.ppd_.tar.gz
tar -zxvf MP540-series.ppd_.tar.gz
sudo cp MP540-series.ppd /etc/cups/ppd/

Merci à Vitali et à ceux qui l’on aidé à réaliser ce tuto.

Vous avez sans doute entendu parler de la Google Dance (mécanisme d’indexation du moteur de recherche de Google) réalisé une ou deux fois par mois ? Et bien depuis MapReduce (août 2004), la Google Dance « Powered by MapReduce » est du quasi temps réel ; Google Maps, Microsoft Bing, Facebook, Twitter etc… C’est encore du « MapReduce Inside ».

MapReduce est un modèle de programmation vulgarisé par les ingénieurs de Google, Jeffrey Dean et Sanjay Ghemawat. L’idée de MapReduce est relativement simple, traiter d’énormes volumes de données sur une architecture distribuée, parallèle et/ou multiprocesseur.

Je ne vais pas, encore une fois, reproduire les multiples exemples qu’on trouve sur le sujet, mais je me devais de faire passer le message. Pour ceux que cela intéresse, voici quelques liens :

• Présentation des recherches de Google sur MapReduce
• Hadoop : implémentation open source de MapReduce.
• MapReduce.org

Il va de soi que nous sommes déjà dans une ère où le volume de donnée à traiter devient colossal pour nos systèmes d’informations. Les machines sont quasiment toutes multiprocesseurs, nous devons adapter nos programmes pour utiliser toutes la puissance du matériel. Cela nécessite une complexité supplémentaire dans les programmes qui doivent être concurrents tout en en étant fiable. Concrètement utiliser des modèles de programmation tels que MapReduce, Threadpool etc… sont une nécessité dès à présent.

Le créateur du langage C++, Bjarne Stroustrup, décrit depuis son site internet les nouvelles fonctions qui intégrerons la future version du langage actuellement encore en version draft.
Cette version est bien avancée, puisque disponible sur les compilateurs les plus importants (GCC, MSVC, etc…).

Parmi les fonctionnalités que j’attends le plus :

• Les threads
• Les opérations atomiques
• Les expressions lambdas
• Les listes d’initialisation
• Construction et destruction dynamiques, concurrentiels d’un objet
• Paramètres variables pour les « Template » (variadic templates)
• etc…

J’ai hâte d’y être, même si je test déjà pas mal des fonctionnalités avec GCC.

Lien : http://www2.research.att.com/~bs/C++0xFAQ.html
Ils en parlent : herbsutter, bertrandleclercq.blogspot.com, danielkitta.org, Visual C++ Team Blog

Si comme moi vous utilisez la librairie C++ Googletest, et que vous compilez vous-même cette librairie, sachez que sous linux (peut-être unix/posix aussi), il faut ajouter la librairie pthread (-lpthread).

J’utilisais la version 1.4.0 qui n’en avait pas besoin, mais depuis un svn update il y a quelques heures, j’ai du ajouter pthread.

Platform: Linux
scons: done reading SConscript files.
scons: Building targets ...
Copy("bin/test/README", "README")
g++ -o bin/test/fpm-test test/main.o src/ratp/fpmanager/fp_helper.o src/external/googletest/src/gtest.o src/external/googletest/src/gtest-death-test.o src/external/googletest/src/gtest-filepath.o src/external/googletest/src/gtest-port.o src/external/googletest/src/gtest-printers.o src/external/googletest/src/gtest-test-part.o src/external/googletest/src/gtest-typed-test.o
src/external/googletest/src/gtest.o: In function `testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::GetOrCreateValue() const':
/home/christian/workspace/fpmanager/src/external/googletest/include/gtest/internal/gtest-port.h:1300: undefined reference to `pthread_getspecific'
...

Avec Scons on peut ajouter quelquechose dans ce style :

if platform == 'linux':
	env.Append(LIBS = 'pthread')

Ça évite de chercher presqu’une heure, une anomalie dans son programme de test !!!

Installer une Ubuntu sur un Netbook est maintenant très aisé avec les solutions basées sur une installation à partir d’une clé USB. De très bon tutoriaux sont présent sur le Net : http://doc.ubuntu-fr.org/ubuntu_netbook_edition#installation

Après une installation facile, rapide et efficace on s’aperçoit que l’interface graphique est très lente ; que se passe t-il ? Pas de pilotes graphiques pour l’Intel GMA 500 (PowerVR) sous linux ? En fait les drivers existent mais sont propriétaires (pour la partie 3D). Ils tournent bien mais ne sont pas tout à fait au point.

Ce qu’on gagne :

• Des performances 2D correctes.
• La lecture vidéo n’est pas top sur la HD et sur certains formats SD, c’est déjà ça.
• Pour la 3D, c’est Néant pour le moment ;-(

Voici les lignes de commandes qui vont faire en sorte de prendre plaisir à utiliser son netbook sous linux.

sudo add-apt-repository ppa:gma500/ppa && sudo aptitude update
sudo aptitude safe-upgrade
sudo aptitude install poulsbo-driver-2d poulsbo-driver-3d poulsbo-config \
psb-kernel-source

Lors de mise à jour du kernel linux, il peut arriver que dkms ne trouve pas les sources du kernel poulsbo, voilà ce qu’il faut faire :

sudo aptitude download psb-kernel-source
sudo dpkg -i psb-kernel-source_4.42.0-0ubuntu2~1004um3.1_all.deb

Si une erreur survient lors de l’installation du fichier deb, réessayé une seconde fois le :

sudo dpkg -i psb-kernel-source_4.42.0-0ubuntu2~1004um3.1_all.deb

La suppression de la version du module précédent pose parfois des soucis à la nouvelle installation.

Et voilà il ne reste plus qu’à rebooter… Il faut noter qu’Asus a corriger le tire en choisissant d’autres puces graphiques sur d’autres modèles de ces netbooks et c’est un bon choix ;  car Intel n’assure pas du tout avec ce GMA500, il est vraiment Naze (espérons que ce soit temporaire). Même pour un netbook il y a un minimum tout de même. Je n’ai plus qu’à économiser pour m’acheter un vrai netbook ou attendre un peu des vrais pilotes !!!

Liens :

• http://doc.ubuntu-fr.org/poulsbo
• http://ubuntuforums.org/showpost.php?p=9598669&postcount=1461

Mon xorg.conf :

# Fichier /etc/X11/xorg.conf

Section "Files"
	ModulePath   "/usr/lib/xorg/modules"
	FontPath     "/usr/share/fonts/X11/misc"
	FontPath     "/usr/share/fonts/X11/cyrillic"
	FontPath     "/usr/share/fonts/X11/100dpi/:unscaled"
	FontPath     "/usr/share/fonts/X11/75dpi/:unscaled"
	FontPath     "/usr/share/fonts/X11/Type1"
	FontPath     "/usr/share/fonts/X11/100dpi"
	FontPath     "/usr/share/fonts/X11/75dpi"
	FontPath     "/var/lib/defoma/x-ttcidfont-conf.d/dirs/TrueType"
EndSection

Section "Monitor"
	Identifier   "Monitor0"
	VendorName   "Monitor Vendor"
	ModelName    "Monitor Model"
EndSection

Section "Screen"
	Identifier "Screen0"
	Device     "Card0"
	Monitor    "Monitor0"
	SubSection "Display"
		Viewport   0 0
		Depth     1
	EndSubSection
	SubSection "Display"
		Viewport   0 0
		Depth     4
	EndSubSection
	SubSection "Display"
		Viewport   0 0
		Depth     8
	EndSubSection
	SubSection "Display"
		Viewport   0 0
		Depth     15
	EndSubSection
	SubSection "Display"
		Viewport   0 0
		Depth     16
	EndSubSection
	SubSection "Display"
		Viewport   0 0
		Depth     24
	EndSubSection
EndSection

Section "Module"
	Load  "glx"
	Load  "record"
	Load  "extmod"
	Load  "xtrap"
	Load  "dbe"
	Load  "dri"
EndSection

Section "DRI"
	Mode	0666
EndSection

Section "InputDevice"
	Identifier  "Keyboard0"
	Driver      "kbd"
EndSection

Section "InputDevice"
	Identifier  "Mouse0"
	Driver      "mouse"
	Option	    "Protocol" "auto"
	Option	    "Device" "/dev/input/mice"
	Option	    "ZAxisMapping" "4 5 6 7"
EndSection

Section "ServerLayout"
	Identifier     "X.org Configured"
	Screen      0  "Screen0" 0 0
	InputDevice    "Mouse0" "CorePointer"
	InputDevice    "Keyboard0" "CoreKeyboard"
EndSection

Section "Device"
	Option      "IgnoreACPI"         	"true"
	Identifier  "Card0"
	VendorName  "Intel Corporation"
	BoardName   "System Controller Hub (SCH Poulsbo) Graphics Controller"
	BusID       "PCI:0:2:0"
	Driver	"psb"
	### Available Driver options are:-
	### Values: <i>: integer, <f>: float, <bool>: "True"/"False",
	### <string>: "String", <freq>: "<f> Hz/kHz/MHz"
	### [arg]: arg optional
	#Option     "ShadowFB"           	# [<bool>]
	#Option     "NoAccel"            	# [<bool>]
	#Option     "SWcursor"           	# [<bool>]
	#Option     "ExaMem"             	# <i>
	#Option     "ExaScratch"         	# <i>
	#Option      "NoPanel"            	"true"
	#Option     "LidTimer"           	# [<bool>]
	#Option     "NoFitting"          	# [<bool>]
	#Option     "DownScale"          	# [<bool>]
EndSection

Arista est une application qui permet de transcoder une vidéo pour plusieurs types d’appareils grâce à un système de presets (réglage automatique) pour ces différents appareils.

On peut l’installer facilement :

sudo aptitude install arista

Mon premier test d’encodage d’une de mes vidéos de vacances pour mon beau téléphone Android échoue.

ERROR: Caught a segmentation fault while loading plugin file:
/usr/lib/gstreamer-0.10/libgstffmpeg.so
Please either:
- remove it and restart.
- run with --gst-disable-segtrap and debug.

Après plusieurs tests, voici les étapes qui m’ont permis d’arriver à mes fins :

sudo aptitude install ubuntu-restricted-extras
sudo aptitude install gstreamer-tools
sudo dpkg --purge --force-depends  gstreamer0.10-ffmpeg
rm -rf ~/.gstreamer-0.10
sudo aptitude reinstall ffmpeg
sudo aptitude install gstreamer0.10-ffmpeg
gst-inspect-0.10

Faites attention de bien avoir ces plugins d’installés sur votre machine :

i A gstreamer0.10-plugins-bad
i   gstreamer0.10-plugins-bad-multiverse
i   gstreamer0.10-plugins-base
i   gstreamer0.10-plugins-base-apps
i   gstreamer0.10-plugins-good
i A gstreamer0.10-plugins-ugly
i   gstreamer0.10-plugins-ugly-multiverse

Voilà le travail….

Pour ceux qui veulent se lancer dans la compilation d’Android sous Ubuntu Lucid Lynx, il faut savoir que cela nécessite de réaliser quelques manipulations supplémentaires.

Tous d’abord le lien du projet pour compiler les sources d’Android (très bien écrit) :

• http://source.android.com/source/download.html

Mais pour notre Ubuntu le problème est java5, qui n’est plus dispo dans les dépôts. Si vous tenter de compiler les sources avec le java6 sous une Ubuntu 32bits, vous tomberez sur un bug indiquant que des entêtes de fichiers C 64bits non trouvés. Dans tous les cas, des parties du code java d’Android ne sont pas supportés par java 6.

Donc la première des choses à faire est de récupérer java5 depuis le site d’Oracle :

• http://java.sun.com/javase/downloads/index_jdk5.jsp

Installer manuellement le java5

chmod a+x jdk-1_5_0_22-linux-i586.bin
./jdk-1_5_0_22-linux-i586.bin
sudo mv jdk1.5.0_22 /usr/lib/jvm/java-5-sun-1.5.0.22
cd /usr/lib/jvm
sudo ln -s java-5-sun-1.5.0.22 java-5-sun

Je n’ai pas trouvé le moyen d’inclure mon install de java5 avec l’outil « update-java-alternatives » qui permet de switcher d’une jvm à l’autre en toute simplicité. Il est toujours possible de créer un fichier « .java-5-sun.jinfo » mais je manque de temps et il existe peut-être un outil pour le faire, n’hésitez pas à me faire signe. (trouvé : http://doc.ubuntu-fr.org/java)

Avant de lancer le make -j4 du tutoriel de google, faites la manip suivante dans le shell (non persistante) :

export JAVA_HOME=/usr/lib/jvm/java-5-sun
export ANDROID_JAVA_HOME=${JAVA_HOME}
export PATH=${JAVA_HOME}/bin:${PATH}

Tenter votre première compilation d’Android générique :

make -j4

Liens

• http://groups.google.com/group/android-building/browse_thread/thread/193332fd6850a2a
• http://source.android.com/source/download.html
• http://java.sun.com/javase/downloads/index_jdk5.jsp

Ça fait maintenant plus d’un mois que je tourne avec le Samsung Spica (I5700) sous Android 2.1 (Eclair). Un android-phone agréable à utiliser. Une prise en main confortable, mais une web expérience assez mitigée. Samsung semble avoir comblé le bide du Galaxy I7500, son premier mobile sous Android. Mais pour avoir eu des retours de personne ayant utilisés le premier modèle, je suis largement plus optimiste sur le Spica. La taille du téléphone est très bien adaptée pour une prise en main efficace. Il faut tout de même un petit temps d’adaptation pour palier l’absence du clavier physique ; le clavier virtuel, surtout en mode portrait, reste un peu délicat à manipuler ; deux ou trois jours d’utilisation intensive sont nécessaires avant de maîtriser la saisie clavier en toute circonstance. L’expérience phone/gsm est plutôt bonne, je pense que c’est le cas pour tous les smartphones ; un bilan plutôt positif sur ce point. La web expérience doit être partagée en deux partie. D’un côté la partie widget/game et de l’autre la partie navigation internet via le « Browser » d’Android.

Widget/Game expérience

La widget-expérience est très bonne. Après avoir testé une multitude d’applications, toutes m’ont donné une impression positive. De la plus simple à la plus complexe, on est toujours étonné qu’un appareil de cette taille soit si agréable. C’est aussi beaucoup du au travail de google de proposer des composants graphiques très bien élaborés et adaptés à ce genre d’utilisation. En terme de jeux, on peut être très satisfait des capacités 2D du Spica. La 3D (sous OpenGL ES) semble peu performante, mais quelques recherches en ligne laissent croire que Samsung doit fournir des drivers plus performants de sa puce S3C6410. Je vous conseille un bon jeu 2D très prenant Robo Defense de Lupis Labs Software. Il y a en fait beaucoup d’autres jeux mais Robo Defense est celui avec lequel je m’éclate le lus en ce moment…

Internet expérience

Comme dit plus haut l’internet-expérience et un peu moins bonne. La taille de l’écran y est pour beaucoup et le peu de site internet optimisé pour les smartphones y contribue énormément à ne pas être à l’aise. On a plus envi de passer sur son portable ou son PC de bureau pour une navigation internet plus aisée. Je n’ai pas eu cette impression sur un Nexus One ou un Iphone 3GS donc je suppose que la gêne vient de la taille de l’écran. Le zoom est accessible grâce à un simple double-click pour avoir une vision adaptée du contenu, mais le scrolling est agaçant.

Conclusion

Quelques regrets…
Pas de version officielle d’Android 2.2 (Froyo), la taille de l’écran un peu petite et peut-être un manque de mémoire interne. Même si on peu installer pas mal d’applications on est tout de même limité. Je pense que l’android-phone de Samsung qui devrait cartonner est le Galaxy S qui est prévu pour septembre 2010 comme étant l’Iphone 4 killer ou concurrent du HTC Evo 4G.

Il faut dire que le Spica reste un très bon rapport qualité/prix dans la gamme moyenne des smartphones.

Cela devient un classique pour moi ; appréhender un langage de programmation se concrétise souvent par l’écriture d’un client NetSoul. L’écriture d’un client NetSoul, nécessite de toucher aux sockets (IO), à la crypto, traitement de chaînes de caractères, gestion des exceptions et erreurs puis parfois aux évènements/notifications/signaux, processus concurrents (Lock/Unlock, Thread) etc… De quoi avoir un avis exhaustif sur le langage de manière assez large.

Globalement le langage GO se rapproche beaucoup des langages de scripting récents, mais le langage est bien dans la famille des langages compilés. La prise en main est assez rapide si l’on maîtrise déjà des langages tels que C/C++, Ruby, Python… Sans connaissance particulière en programmation c’est possible de commencer par le langage GO, mais je fais parti de ceux qui pense que la programmation s’apprend avec le « C« .

Exemple d’un client NetSoul écrit en GO

GO est un langage de programmation propulsé par Google. L’objectif premier de GO est de proposer un langage rapide à l’exécution et à la compilation, qui soit safe (multi-threading, multi-processus, gestion de la mémoire), facile à programmer et en même temps bas niveau. Est-ce possible ? Allez GO…

Préparer son environnement de développement

sudo aptitude install bison gcc libc6-dev ed gawk make
sudo aptitude install python-setuptools python-dev build-essential
sudo easy_install mercurial
mkdir $HOME/bin
mkdir $HOME/go

Ajouter les lignes suivantes dans le fichier « ~/.bashrc »

export GOBIN=${HOME}/bin # Obligatoire si le choix de l'emplacement est différent de ${HOME}/bin (pensez à ajouter ce chemin dans $PATH)
export GOROOT=${HOME}/go
export GOARCH=386 # Ou amd64, arm
export GOOS=linux
export PATH=${GOBIN}:${HOME}/bin:${PATH}

Récupérer et compiler GO

. ~/.bashrc
hg clone -r release https://go.googlecode.com/hg/ $GOROOT
cd $GOROOT/src
LANG=en_US ./all.bash

Écrire le fameux « Bonjour le monde »

cat > bonjour.go <<EOF
package main
import "fmt"
func main() {
	fmt.Printf("Bonjour le monde !!!\n")
}
EOF
8g bonjour.go
8l -o bonjour bonjour.8
./bonjour

Liens :

1. Tutoriel GO
2. En savoir plus sur les librairies du langage GO

Signer une application Android n’est pas bien compliqué. Ces quelques vont vous guider dans la préparation du certificat. Il faut bien entendu avoir une plate forme Android fonctionelle.

mkdir -p ~/.local/share/keystore
cd ~/.local/share/keystore
keytool -genkey -v -keystore android-release-key.keystore -alias mon_alias -keyalg RSA -validity 10000

Il ne vous reste plus qu’à répondre aux questions…

Pour signer une application, le plus simple est d’utiliser ant. Il suffit de renseigner les deux lignes ci-dessous dans le fichier build.properties à la racine de votre projet :

# fichier : build.properties
key.store=/home/christian/.local/share/keystore/android-release-key.keystore
key.alias=mon_alias

Lorsque vous compiler votre projet avec la commande ant, il faut renseigner le ou les mots de passe de votre certificat, puis à la racine du projet tapez :

ant release

Il est aussi possible de réaliser la signature de vos applications à la main, je vous conseille dans ce cas le tutoriel android traitant directement du sujet. il ne reste plus qu’à déployer l’application.

Pour installer votre application sur l’émulateur ou votre device, il faut utiliser l’outil ADB ou passer par Eclipse/ADT.

Pour les développeurs qui n’ont pas encore de mobile Android, il est impossible de tester l’Android Market et ce, même depuis les images pour l’émulateur livré avec le SDK. Avec un peu de ruse il est possible, de jouer avec les applications disponibles depuis le market. Pour ce faire nous allons utiliser les images fournit par HTC sur leur portail dédié aux développeurs.

Je vous conseille de suivre mon article sur la mise en place d’une plate-forme de développement Android sous linux : http://www.kakesa.net/os-design/installer-le-sdk-android-et-eclipse-adt-ubuntu-9-10/139 si vous n’en avez pas encore.

Créer un répertoire temporaire pour stocker l’image du firmware du HTC Dream, par exemple /tmp/android :

mkdir -p /tmp/android
unzip signed-dream_devphone_userdebug-img-14721.zip
chmod a+r *.img

L’image récupéré depuis le site de HTC étant celui d’une version 1.6, créons un avd de la même version et copions-y l’image HTC :

android list target
android create avd -t 3 -n avd1.6
cp /tmp/android/system.img ~/.android/avd/avd1.6.avd/

Lançons l’émulateur :

emulator -avd avd1.6

1. Cliquez sur le logo Android à l’écran
2. Suivez le tutoriel ou passez-le
3. Utilisez votre compte google ou choisissez de le créer
4. Sélectionnez une application du Market et installez-là

[st transition=wipeh width=600 height=563 quality=best scale=noborder showtext=on fullscreen=off autoplay=on source=full]






[/st]

Voici un petit tutoriel pour installer le SDK Android ainsi que l’IDE Eclipse et son plugin ADT permettant de réaliser ses premières lignes de code sous l’OS de Google. Je vous conseille de tester l’émulateur afin de vous familiariser avec Android. D’autres articles suivront sur la manière de réaliser ses premières applications.

Première étape installer java-6 et Ant

sudo aptitude install sun-java6-bin ant

Installer Eclipse et son plugin ADT

sudo aptitude install eclipse

Installer le plugin ADT pour eclipse

Ici l’installation d’Eclipse permet de faciliter vos futurs développements, je vous conseil, dans un premier temps, de privilégier les commandes shell pour mieux maîtriser le développement sous Android.

• Lancer eclipse
• Help > Install New Softare

• Cliquer sur « Add » ajouter les « Software sites » suivants :
• Selon le schéma [Name] – [Location]
  1. ADT – https://dl-ssl.google.com/android/eclipse/
  2. Eclipse GEF – http://download.eclipse.org/tools/gef/updates/releases/
  3. Eclipse EMF – http://download.eclipse.org/modeling/emf/updates/releases/
  4. Eclipse GMF – http://download.eclipse.org/modeling/gmf/updates/releases
  5. Eclipse Webtools – http://download.eclipse.org/webtools/updates/
  6. Google eclipse Plugin – http://dl.google.com/eclipse/plugin/3.5

• Sélectionner « Developer Tools » et assurez-vous que « Contact all update sites during install… » soit coché, puis suivez le guide…

Installer le SDK

mkdir -p ~/.local/opt
cd ~/.local/opt

Télécharger le SDK Android dans ~/.local/opt/

tar -zxvf android-sdk_r3-linux.tgz
cd android-sdk-linux/tools/
echo "export PATH=$(pwd):\${PATH}" >> ~/.bashrc
. ~/.bashrc

Mettre à jour le SDK

android update sdk

Faites connaissance avec l’émulateur Android

Lister les firmware disponible et identifier l’ID d’une version qui vous intéresse

android list targets

Créer un avd et lancer l’émulateur (-t : Id précédemment identifié)

mksdcard -l sdcard-avd2.0_API5 4096M ~/.android/sdcard-avd2.0_API5
android create avd -n avd2.0_API5 -t 7
emulator -avd avd2.0_API5 -sdcard ~/.android/sdcard-avd2.0_API5

StAX pour Streaming Api for Xml est une méthode performante pour parser un document XML. Voici un petit article qui montre les bien faits de cette méthode permettant de parcourir un fichier XML. On connaît bien les méthodes DOM (Document Object Model) et SAX (Simple Api for Xml), mais un peu moins sur le StAX méthode dite de pull parsing.

Pour rappel, la méthode DOM a pour fonctionnement le chargement en mémoire de l’ensemble d’un fichier XML sous forme d’arbre ou tableau etc… Cette méthode convient pour des fichiers de petite taille mais pour des fichiers de plusieurs centaines de mégaoctets voir quelques gigaoctets, ce mode est très lent. DOM a la particularité de pouvoir parcourir un fichier dans un sens comme dans l’autre et de permettre l’écriture et la modification de nœuds XML. Le mode de parcours SAX est un mode dit de push parsing (évènement implémenté/déclenché du côté de l’API) qui permet le parcours d’un fichier uniquement vers l’avant. SAX consomme très peu de mémoire, et reste très rapide mais ne permet pas la modification de nœuds XML.

La notion de pull parsing pour le StAX vient du fait que l’évènement est demandée du côté du code client (comprendre le code client en dehors de l’API XML). Le parseur est ce qu’on appelle « stream based », le code client soumet la portion de code a analyser par le parseur et récupère entre autre un évènement au quel on choisira de réaliser une action.
Le pull parsing oblige une analyse vers l’avant uniquement et permet l’écriture mais pas la modification de nœuds XML. Les performance sont très élevées pour le parcours de fichiers volumineux.

Parseur de type StAX :

• Expat (C)
• SPXML (C++)
• Plusieurs implémentations en JAVA basées sur la JSR-173 (JAVA)

Ci-dessous un exemple d’utilisation du parseur SPXML en mode StAX (supporte aussi DOM). On peut voir que le code utilisateur implémente les actions de traitement et non une redéfinition de méthodes de l’API comme en SAX. Notons que j’ai choisit de parcourir le fichier donné en paramètre, ligne à ligne, mais StAX étant stream based (basé sur des flots de données), il possible de parcourir selon un nombre d’octet définit.

int main( int argc, const char * argv[] )
{
	std::string filename;
	if( argc != 2 )
	{
		std::cout << "Usage:" << argv[0] << " <xml_file>" << std::endl;
		return (-1);
	}
	else
		filename = argv[1];

	SP_XmlPullParser parser;
	std::string line;
	std::ifstream myfile(filename.c_str());
	if (myfile.is_open())
	{
		while (!myfile.eof())
		{
			std::getline(myfile, line);
			parser.append( line.c_str(), line.length() );
			for( SP_XmlPullEvent * event = parser.getNext(); NULL != event; event = parser.getNext() )
			{
				switch( event->getEventType() )
				{
					case SP_XmlPullEvent::eStartDocument:
						std::cout << "start document" << std::endl;
						break;
					case SP_XmlPullEvent::eEndDocument:
						std::cout << "\nend document" << std::endl;
						break;
					case SP_XmlPullEvent::eDocDecl:
					{
						SP_XmlDocDeclEvent * declEvent = (SP_XmlDocDeclEvent*)event;
						std::cout << "<?xml";
						if( '\0' != *declEvent->getVersion() )
							std::cout << " version=\"" << declEvent->getVersion() << "\"";

						if( '\0' != *declEvent->getEncoding() )
							std::cout << " encoding=\"" << declEvent->getEncoding() << "\"";

						if( -1 != declEvent->getStandalone() )
							std::cout << " standalone=\""<< (declEvent->getStandalone() ? "yes" : "no") << "\"";

						std::cout << "?>" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eDocType:
					{
						SP_XmlDocTypeEvent * typeEvent = (SP_XmlDocTypeEvent*)event;
						std::cout << "<!DOCTYPE " << typeEvent->getName() << " PUBLIC \"" << typeEvent->getPublicID() << "\" SYSTEM \"" << typeEvent->getSystemID() << "\" \"" << typeEvent->getDTD() << "\">" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eStartTag:
					{
						SP_XmlStartTagEvent * stagEvent = (SP_XmlStartTagEvent*)event;
						std::cout << "<" << stagEvent->getName();
						for( int i = 0; i < stagEvent->getAttrCount(); i++ )
						{
							const char * name = NULL, * value = NULL;
							name = stagEvent->getAttr( i, &value );
							std::cout << " " << name << "=\"" << value << "\"";
						}
						std::cout << ">" << std::endl;
						break;
					}
					case SP_XmlPullEvent::eEndTag:
						std::cout << "</" << ((SP_XmlTextEvent*)event)->getText() << ">" << std::endl;
						break;
					case SP_XmlPullEvent::eCData:
					{
						SP_XmlStringBuffer buffer;
						SP_XmlStringCodec::encode( parser.getEncoding(),
						((SP_XmlTextEvent*)event)->getText(), &buffer );
						std::cout << buffer.getBuffer() << std::endl;
						break;
					}
					case SP_XmlPullEvent::eComment:
						std::cout << "<!--" << ((SP_XmlTextEvent*)event)->getText() << "-->" << std::endl;
						break;
					case SP_XmlPIEvent::ePI:
						std::cout << "<?" << ((SP_XmlPIEvent*)event)->getTarget() << " " << ((SP_XmlPIEvent*)event)->getData() << "?>" << std::endl;
						break;
				};
				delete event;
			}
		}
		myfile.close();
		if( NULL != parser.getError() )
			std::cerr << "\nerror: " << std::string(parser.getError()) << std::endl;
	}
	else
		std::cerr << "\nCan't open " << filename << " !!!" << std::endl;

	return 0;
}

Cela fait maintenant 1 semaine que la nouvelle version d’Ubuntu est sortie. Nom de code Karmic Koala. Pour ceux qui veulent réaliser une mise à jour dans les règles de l’art, voilà le secret :

$ sudo aptitude update
$ sudo aptitude safe-upgrade
$ sudo update-manager -d

Il ne reste plus qu’à se laisser guider et tester cette nouvelle version. La mise à jour depuis une Ubuntu Jaunty Jakalope est très simple. Il est possible, aussi, de télécharger l’image CD ISO pour une installation complète :

• http://www.ubuntu-fr.org/telechargement/

OsiLink est un projet qui vise à mettre en relation des développeurs qui sont soit à la recherche d’un projet de développement soit à la recherche de compétences pour la réalisation d’un projet open source.

C’est du 19 au 21 novembre 2009 à San Francisco qu’aura lieu la RubyConf de cette année. C’est l’occasion de pour les plus chanceux de se mettre à jour sur les nouveautés et retour d’expérience directement liés à la technologie Ruby.

Au passage voici une adresse qui permet de trouver des vidéos interressante sur Ruby et RubyOnRails : http://envycasts.com/.

Cette année le projet PostgreSQL a choisit Paris pour sa conférence annuelle internationale. Le rendez-vous est donné pour les 6 et 7 novembre 2009 à Télécom ParisTech. Deux jours de conférences pour tous les niveaux en anglais et français.

Au programme, des retours d’expériences, technique de mise en place de dataware house, calcul spatial, étude de cas, développement agile etc…

S’inscrire à l’évènement : http://2009.pgday.eu/fr:register.

Mon blog fait peau neuve. Au programme toujours beaucoup de techno linux et certainements de grosses réflexion autour du web et et son développement.

Retrouvrez mon ancien blog sur : http://ancienblog.kakesa.net/

Le ton est donné !!!