Archive for Dossiers Techniques

image_pdfimage_print

Le versioning des Web Service

Récemment, j’ai été confronté à la remise à plat d’un SI avec la volonté d’articuler celui-ci autour de la SOA. L’utilisation de Web Service n’a de valeur que si ces derniers sont utilisés par de multiples applications. Mais dans ce cas, comment gérer l’indépendance des services qui est une des briques angulaires de cette architecture. En effet, chaque service doit pouvoir vivre de son coté (modification, maintenance, déploiement) sans impacter (ou tout du moins le moins possible) ses consommateurs. Donc une stratégie de versioning doit être mise en place ! Mais comment ?

Read more

Facebook sait quand vous êtes sur le point de mettre à jour votre Statut

Il y a quelque mois Amazon a déposé  un brevet qui explique comment il est capable d’anticiper les commandes des clients. Aujourd’hui et plus exactement, le jour de Saint-Valentin, le géant de réseaux sociaux, Facebook a mis en place une application qui permet de prédire quand deux personnes entament une relation officielle Facebook «in relationship» et ceci en se basant sur les « posts »  partagés entre les deux personnes. En effet, douze jours avant le changement de statut, le nombre de «posts partagés» entre les deux personnes, atteint 1.67 messages. Ce nombre diminue significativement après le changement de statut. Evidemment, d’autres paramètres entrent en ligne de compte dans cette étude ;  je vous laisse lire en détails le reste de l’article à cette adresse.

FacebookChart

Méthodologie agile SCRUM

Méthodologie agile SCRUM

 

1.   Qu’est ce que la méthodologie Agile SCRUM ?

Scrum est une méthode agile dédiée à la gestion de projets. Son objectif est d’améliorer la productivité des équipes auparavant ralenties par des méthodologies plus lourdes.

Scrum ne propose aucune pratique de développement, juste des pratiques de management. Il s’agit en fait d’un cadre de gestion de projets bien adapté aux méthodes de développement agile

Le terme Scrum est emprunté au rugby à XV et signifie mêlée. Ce processus s’articule en effet autour d’une équipe soudée, qui cherche à atteindre un but, comme c’est le cas en rugby pour avancer avec le ballon pendant une mêlée.

Le principe de base de Scrum est de focaliser l’équipe de façon itérative sur un ensemble de fonctionnalités à réaliser, dans des itérations de durée fixe de une à quatre semaines, appelées sprints. Chaque sprint possède un but à atteindre, défini par le directeur de produit, à partir duquel sont choisies les fonctionnalités à implémenter dans ce sprint. Un sprint aboutit toujours sur la livraison d’un produit partiel fonctionnel. Pendant ce temps, le ScrumMaster a la charge de réduire au maximum les perturbations extérieures et de résoudre les problèmes non techniques de l’équipe.

AllScrum

Un principe fort en Scrum est la participation active du client pour définir les priorités dans les fonctionnalités du logiciel et pour choisir celles qui seront réalisées dans chaque sprint. Il peut à tout moment compléter ou modifier la liste des fonctionnalités à réaliser, mais jamais celles qui sont en cours de réalisation pendant un sprint.

2.   L’organisation 

2.1 Les rôles

La méthodologie SCRUM fait intervenir 3 rôles principaux qui sont :

  • Responsable produit – Product owner :
    • Il est le responsable produit  de l’équipe projet client.
    • Il définir et priorise la liste des fonctionnalités du produit et choisir la date et le contenu de chaque sprint sur la base des valeurs (charges) qui lui sont communiquées par l’équipe.
    • Il explicite les éléments (Items) du carnet du produit.
    • Ces composants sont sous forme des User Stories : Un User Story est une phrase simple dans le langage de tous les jours permettant de décrire avec suffisamment de précision le contenu d’une fonctionnalité à développer.
    • La phrase contient généralement trois éléments descriptifs de la fonctionnalité: Qui? Quoi? Pourquoi?
    • En tant que <qui>, je veux <quoi> afin de <pourquoi>
    • Enfin, il valide fonctionnellement les développements.
  • ScrumMaster :
    • Véritable facilitateur sur le projet,
    • Il veille à ce que chacun puisse travailler au maximum de ses capacités en éliminant les obstacles et en protégeant l’équipe des perturbations extérieures.
    • Il porte également une attention particulière au respect des différentes phases de SCRUM. Il participe aux développements des fonctionnalités
  • Equipe de projet :
    • une taille allant de 4 à 10 personnes en général, l’équipe regroupe tous les rôles habituellement nécessaires à un projet, à savoir l’architecte, le concepteur, le développeur, le testeur, etc.
    • L’équipe s’organise elle-même et elle reste inchangée pendant toute la durée d’un sprint.

2.2 Les événements

Le sprint:

Tout au long de la vie du projet, de la phase des spécifications jusqu’à la mise en production, le travail est réparti en sprints et releases. Un sprint est une itération, d’une durée allant de 2 à 4 semaines. Un release est une somme de sprints, améliorant la visibilité sur le planning du projet.

Sprint

On définit, en début du projet un ensemble de fonctionnalités à développer. Les fonctionnalités sont réparties en releases. C’est ce qu’on appelle le back log produit et back log release. Au début de chaque sprint on planifie et distribue les items du back log de la release. Tout au long du projet il est possible d’ajouter ou de supprimer des items du back log d’un sprint.

Le principal avantage de cette méthode est que chaque sprint est intégré et testé. Toutes les fonctionnalités développées durant le sprint sont pleinement fonctionnelles et permettent de supprimer l’effet tunnel lors des développements.

Point quotidien – Daily Scrum :

Daily Scrum  est une réunion qui dure 15 minutes au maximum. Elle permet aux développeurs de faire un point de coordination sur les tâches en cours et sur les difficultés rencontrées.

Le Scrum Master s’assure que la réunion ait lieu à heure fixe.

Le Product owner  du produit n’est pas présent.

À tour de rôle, chaque membre répond à 3 questions :

•     Qu’ai-je fait hier ?

•     Que dois-je faire aujourd’hui ?

•     Quelles sont les difficultés rencontrées ?

Cette réunion a un but de synchronisation pour l’équipe et ne doit pas être vécue comme un reporting d’activité.

Sprint Planning Meeting :

Toute l’équipe se réunit pour décider des fonctionnalités qui vont composer le sprint suivant et mettre à jour la liste générale.

Les réunions de revue de travail (démonstration) :

Lors de cette réunion, chacun présente ce qu’il a fait pendant la durée du sprint. Une démonstration des nouvelles fonctionnalités ou de présentation de l’architecture est organisée. Il s’agit d’une réunion informelle de 2 heures environ à laquelle participe toute l’équipe.

Les réunions de rétrospectives :

A chaque fin de sprint, l’équipe fait le point sur ce qui a bien fonctionné et sur ce qui a moins bien fonctionné. Lors de cette réunion d’une durée de 15 à 30 minutes où chacun est invité et parle en son nom, un vote de confiance est organisé pour décider des améliorations à apporter.

Utiliser Karaf dans une architecture en cluster

karaf-logoLors de la première partie du tuto “Développement OSGI pour serveur Karaf“, nous avions vu que le serveur Apache Karaf avait un certains nombres de qualités intéressantes dont la capacité à créer des instances filles en quelques lignes de commande.
Mais j’avais omis un petit détail qui peut avoir son importance, cette qualité va lui permettre de travailler en mode DOSGi.

Read more

Enfin, OpenCV est disponible pour les codeurs java !

logoOpenCVOpenCV est une bibliothèque de traitement d’image ou plus généralement une bibliothèque graphique développée principalement avec le langage C++ par la société Intel dont Willow Garage assure le support depuis 2008. D’autres grands acteurs du domaine s’intéressent à OpenCV , tel que Nvidia. Cette dernière développe depuis quelques années des briques utilisant CUDA pour OpenCV . Ceci permet d’exploiter les avancées en termes de puissance de calcul graphique GPU.

Début 2007 et début octobre 2008, sont deux dates connues par l’apparition des smartphones équipés par un iOS ou par un androïd. Ces deux merveilles ont révolutionné le marché des Smartphones et des tablettes. En plus des fonctionnalités d’un simple téléphone, un Smartphone peut contenir des centaines d’applications allant d’une simple application agenda à une application plus complexe utilisant plus de ressources, réseaux, capteurs (caméra), etc. Les applications pour iPhone sont développées avec le langage de programmation Objective-C, tandis que les applications pour Androïd sont développées avec le langage de programmation Java. Ce dernier est connu pour sa portabilité. Un Smartphone comporte le plus souvent une caméra produisant des images de très bonne qualité. Outre la reprise des photos, une caméra peut être utilisée dans plusieurs applications, webcam, réalité virtuelle, reconstruction 3D, reconnaissances d’objets, etc. Ces dernières applications nécessitent des algorithmes de traitement et d’analyse d’images plus complexes. Heureusement, OpenCV est leader dans le domaine et surtout est très en avance sur ces sujets. Alors pourquoi réinventer la roue ? Il est donc impératif pour la librairie OpenCV de développer des interfaces qui permettent de s’interfacer avec d’autres langages et plus particulièrement les deux langages les plus populaires à savoir Java et Python. Dans ce tutoriel, nous nous intéressons plus particulièrement au langage Java.

Pour un développeur java, il existe plusieurs solutions qui permettent d’intégrer du code C++ dans un programme Java. Nous pouvons citer comme exemple : JNI, SWIG, etc. Ces solutions restent très difficiles à mettre en œuvre et surtout à maintenir. Pour chaque version C++, le développeur java réadapte son code pour intégrer les changements. JavaCV est un bon exemple.

Souvent, les développeurs Java abandonnent les avantages d’OpenCV et cherchent plutôt d’autres bibliothèques purement java ou d’autres bibliothèques qui embarquent une interface java. Je donne par exemple imageJ et Orefo ToolBox (otb). Cette dernière est très puissante mais malheureusement elle est limitée aux problématiques de télédétection. Dans cet article, je ne compare pas les librairies en détails, mais au niveau des fonctionnalités, je pense qu’OpenCVdépasse largement ses concurrents, en tout cas dans des applications de traitement d’images plus particulièrement “génériques”.

Dans ce guide, vous trouverez une aide pour créer votre premier projet Java en utilisant OpenCV. Pour mener à bien notre objectif, nous allons utiliser Eclipse.

Le guide se déroulera en trois étapes :

  1. Installer OpenCV avec une prise en charge Java.
  2. Créer un projet Eclipse.
  3. Écrire un projet simple OpenCV avec Java.

Installation OpenCV avec support Java

A partir de la version 2.4.4 OpenCV intègre une interface avec le langage Java. Pour bénéficier de cette fonctionnalité, nous allons télécharger et installer la version OpenCV 2.4.4 ou une autre version plus récente depuis le dépôt : http://sourceforge.net/projects/opencvlibrary/. Pour le bon déroulement du tutoriel, nous supposons que cmake, java, ainsi que python sont bien installés. Sinon, pour les utilisateurs de Debian / ubuntu lancer la commande :

$>sudo aptitude install cmake default-jdk openjdk-7-jdk python python-dev

Ensuite, nous allons cloner OpenCV depuis un serveur git avec la commande

$>git clone git://github.com/Itseez/opencv.git
$>cd opencv
$>git checkout 2.4.6
$>mkdir build
$>cd build

Avec cmake, nous générons le fichier MakeFile en lançant la commande suivante:

$>cmake -DBUILD_SHARED_LIBS=OFF ..

L’option BUILD_SHARED_LIBS est désactivée, ceci permet de générer la librairie d’interface java contenant seule toutes les dépendances d’OpenCV.
Ensuite, il faut examiner la sortie de cmake afin de vérifier que le module java sera bien généré. Ci-dessous, vous avez un aperçu de cette sortie. J’ai souligné le module java.

opencvModules

J’ai ajouté dans la commande précédente de “aptitude” des dépendances Python afin de générer aussi l’interface Python pour OpenCV . Je ne donnerai pas un exemple de projet Python utilisant OpenCV , mais l’installation est un bon début. Je vous laisse faire la suite.
Une fois la génération de MakeFile est terminée, lancer la compilation :

$>make -j2

image15

A la fin de ce processus, vous aurez dans le répertoire bin votre interface opencv_2.4.6.jar ainsi que la librairie libopencv_java_246.so. Ces deux fichiers seront utiles et nécessaires pour la prochaine étape.

Création d’un projet Java sous Eclipse

Maintenant nous allons exploiter OpenCV dans un programme Java en utilisant l’IDE Eclipse.

  • Créer un nouvel espace de travail.
  • Activer une perspective Java.
  • Créer un nouveau projet Java : Fichier -> Nouveau –> Projet Java
    nouveau projet Java
  • Ouvrir “Java Build Path” à partir de “Project Properties” afin de configurer les librairies :
  • Capture du 2013-10-29 14:14:10
  • Cliquer sur “add library” , “User Library” puis “Next”
    Capture du 2013-10-29 14:16:47
  • Cliquer sur “User libraries”
    Capture du 2013-10-29 14:22:49
  • Ensuite cliquer sur “New”
    Capture du 2013-10-29 14:23:05
  • Donner un nom pour votre librairie: par exemple “opencv_2.4.6″ puis “ok”.
    Capture du 2013-10-29 14:48:41
  • Sélectionner opencv-2.4.6 puis “add external JARs”.
    Capture du 2013-10-29 14:24:42
  • Sélectionner “Native library location” puis “Edit”
    Capture du 2013-10-29 14:49:18
  • Entrer le chemin vers “libopencv_java246.so” puis ok.
    Capture du 2013-10-29 14:50:02

Projet simple OpenCV avec Java

  • Maintenant, votre projet est configuré avec OpenCV (lib et jar) et il est prêt pour un test. Nous allons maintenant crée une classe Main.java avec le contenu ci-dessous :
    import org.opencv.core.Core;
    import org.opencv.core.CvType;
    import org.opencv.core.Mat;
    
    public class Main {
        public static void main(String[] args) {
            System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
            Mat m  = Mat.eye(3, 3, CvType.CV_8UC1);
            System.out.println("m = " + m.dump());
        }
    }
    

    Capture du 2013-10-29 14:55:45

  • Ensuite, cliquer sur “Run” et trouver dans le console d’Eclipse : la matrice identité.
    Capture du 2013-10-29 15:10:21

Conclusion

Avec ces quelques lignes, je pense que vous serez maintenant capable de débuter un projet Java simple utilisant la librairie OpenCV .
Bientôt sur notre site :

  1. Projet Java-Opencv de détection de visage.
  2. Projet de génération d’un dépôt maven incluant la librairie opencv.jar.
  3. Projet Java-Opencv pour Android.

Redis, un moteur de base de données en mémoire

Redis (REmote Dictionary Server) est un moteur de base de données en mémoire développé à partir de 2009 par un développeur italien nommé Salvatore Sanfilippo. Ce dernier ainsi qu’un contributeur important de Redis (Pieter Noordhuis) sont recrutés par VMWare en 2010 pour se consacrer à plein temps sur le développement de Redis tout en laissant en licence libre BSD. Redis est écrit avec le langage de programmation C ANSI. Redis fait partie des solutions NoSQL et il se distingue par sa rapidité, son efficacité et sa légèreté. Par exemple, en terme de rapidité il est très difficile à battre, tant en lecture qu’en écriture. Il peut traiter plus de 100 000 opérations par seconde.

PRESENTATION

Redis est un moteur non relationnel qui opère principalement en mémoire. Il manipule des structures de données clé-valeur. Il est à la fois gestionnaire de ces types de données et un cache de données à la manière de memcached (un système d’usage général servant à gérer la mémoire cache distribuée. Il est souvent utilisé pour augmenter la vitesse de réponse des sites web (Facebook, Twitter, Wikipedia) créés à partir de bases de données. Il gère les données et les objets en RAM de façon à réduire le nombre de fois qu’une même donnée stockée dans un périphérique externe est lue.

TYPES DE DONNEES

Contrairement autres solutions NoSQL qui opèrent sur des documents (json, xml, etc), Redis manipule des paires clé-valeur, les valeurs peuvent être de cinq types de données : chaines, listes, ensembles, hachages et ensembles triés. Ci-dessous, nous détaillons ces cinq types de données.

Chaînes

Une chaîne en Redis est plus qu’une chaîne standard. Elle permet de stocker aussi de stocker des valeurs numériques et des valeurs binaires. Ces dernières permettent par exemple de stocker une image en mémoire. Ceci afin d’éviter le codage et décodage de format image. La taille maximale est de 512 Mo. D’autres commandes sont intégrées spécialement pour modifier des chaînes de type numérique INCR, INCRBY, DECR, DECRBY. Nous verrons toutes ces commandes dans les sections de travaux pratiques.

Listes

Les listes sont simplement des listes de chaînes.

Ensembles

Un ensemble est une collection non triée de chaînes. Quelques opérateurs ensemblistes sont disponibles au niveau de serveur Redis : union, intersection et différence.

Hachages

Il représente un dictionnaire, ce qui permet de stocker des objets par exemple (de la même façon qu’un document JSON). Le stockage est optimisé, ce qui fait que le hachage prend moins de place en mémoire.

Ensembles triés

L’ensemble trié se comporte comme un ensemble où chaque élément de l’ensemble est associé à un poids ou un score qui permet de trier l’ensemble.

PRATIQUES

Dans ces lignes, nous détaillons comment installer Redis, comment le configurer, donner quelques exemples de base pour manipuler les cinq types de données Redis, et enfin un projet complet Redis en utilisant CMake, Hiredis.

Installation

Redis est disponible sous forme de paquet dans plusieurs distributions : Debian, Ubuntu, etc. Sous Ubuntu ou Debian, le paquet est nommé : redis-server. Pour l’installer, il faut tout simplement lancer la commande :
#$> sudo aptitude install redis-server

Ensuite, une fois l’installation terminée, nous pouvons démarrer le serveur en lançant la commande :
#$> nohup redis-server
Avec cette commande le serveur démarre avec les paramètres par défaut. Si nous souhaitons les personnaliser alors, nous avons deux façons :
#$> nohup redis-server /etc/redis/redis.conf &
ou
#$> nohup redis-server --port 5555 --slaveof 127.0.0.1 8888 &

Dans la première commande les valeurs des paramètres sont renseignées dans le fichier de configuration redis.conf. Cependant dans la deuxième commande, les paramètres sont passés dans la ligne de commande.

Enfin, pour s’assurer que le serveur Redis est bien démarré, vous pouvez lancer la commande :
#$> Redis-cli ping
#$> PONG

Information serveur

Avant de personnaliser les paramètres de serveur Redis, il est utile de jeter un coup d’oeil sur la commande : INFO Pour lancer cette commande, il faut passer par redis-cli. Ce dernier est livré avec Redis-server. Redis-cli est une invite interactive qui permet d’envoyer des commandes au serveur.

#$> redis-cli
redis 127.0.0.1:6379> INFO
redis_version:2.4.14
redis_git_sha1:00000000
redis_git_dirty:0
arch_bits:64
multiplexing_api:epoll
gcc_version:4.6.2
process_id:5793
uptime_in_seconds:83
uptime_in_days:0
lru_clock:1410105
used_cpu_sys:0.00
used_cpu_user:0.04
used_cpu_sys_children:0.00
used_cpu_user_children:0.00
connected_clients:1
connected_slaves:0
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
used_memory:726144
...

La commande INFO fournit un aperçu utile sur les informations et les paramètres de serveur Redis, y compris la version, ID de processus, la mémoire utilisée, la mémoire disponible, le numéro de port, l’adresse de serveur ; etc.

Configuration

Le serveur Redis possède plusieurs paramètres de configuration. Pour les personnaliser, nous pouvons lancer le serveur avec notre propre fichier de configuration. Afin de faciliter cette tâche, vous pouvez vous servir du fichier de configuration d’exemple redis.conf téléchargeable depuis cette adresse : https://github.com/antirez/redis. Voici un aperçu de fichier de configuration :

Utilisation de redis-cli

Dans cette section, nous utilisons redis-cli pour manipuler les types de données de base dans Redis.

redis 127.0.0.1:6379[1]> EXISTS mykey
(integer) 0
redis 127.0.0.1:6379[1]> APPEND mykey "hello"
(integer) 5
redis 127.0.0.1:6379[1]> APPEND mykey " world"
(integer) 11
redis 127.0.0.1:6379[1]> GET mykey
"hello world"

Je vérifie si mykey existe dans la base de données, puis je lui associée la valeur hello. Ensuite je concatène à cette valeur le mot word. En fin, avec la commande GET j’affiche le contenu de mykey. Vous remarquez que le serveur Redis répond toujours par le nombre de caractère du contenu de ma clé.
D’autres commandes peuvent être utiles si la valeur associée à une clé est de type numérique.

redis 127.0.0.1:6379> SET mykey "10"
OK
redis 127.0.0.1:6379> INCR mykey
(integer) 11
redis 127.0.0.1:6379> GET mykey
"11"

La liste des commandes concernant les chaînes se trouve à cette adresse : http://redis.io/commands#string

Avec Hache, nous pouvons stoker un objet. Supposons que nous avons besoin de stocker un article. Avec Redis la commande sera :

redis 127.0.0.1:6379> hmset article:1 prenom "Pierre" nom "Durand" email "pierre.durand@conceptit.fr" titre "Redis, quand on l'essaie, on l'adopte"
OK
redis 127.0.0.1:6379> hvals article:1
1) "Pierre"
2) "Durand"
3) "pierre.durand@conceptit.fr"
4) "Redis, quand on l'essaie, on l'adopte"
redis 127.0.0.1:6379> hget article:1 email
"pierre.durand@conceptit.fr"

D’autres commandes concernant cette fois les dictionnaires sont détaillées depuis cette adresse : http://redis.io/commands#hash

Si vous souhaitez utiliser les transactions, Redis met a votre disposition deux commandes MULTI et EXEC. MULTI commance une transaction. Toutes les instructions qui suivent seront stockées dans une file d’attente et ne seront exécutées qu’après l’appel de la commande EXEC. DISCARD permet d’annuler la transaction.

redis 127.0.0.1:6379> append mykey "hello"
(integer) 5
redis 127.0.0.1:6379> Multi
OK
redis 127.0.0.1:6379> append mykey " world"
QUEUED
redis 127.0.0.1:6379> get mykey
QUEUED
redis 127.0.0.1:6379> renamenx mykey macle
QUEUED
redis 127.0.0.1:6379> get macle
QUEUED
redis 127.0.0.1:6379> EXEC
1) (integer) 11
2) "hello world"
3) (integer) 1
4) "hello world"

APPLICATION CLIENTE

Dans cet article, j’ai choisi de vous donner un exemple d’application totalement développée avec le langage C++. Pour faire le pont entre notre application et Redis, nous utilisons Hiredis. Ce dernier existe en paquet pour debian et ubuntu sous le nom libhiredis-dev pour l’installer en même temps que cmake, il faut taper la commande :
sudo aptitude install cmake libhiredis-dev
Pour avoir cmake en interface graphique, il faut ajouter le paquet : cmake-curses-gui

Ingrédients

  1. CMake,
  2. Redis-server,
  3. libhiredis-dev

Préparation

Dans un répertoire nommé par exemple “projet”, créer deux sous répertoires : build, src. Ensuite créer un fichier texte nommé CMakeLists.txt.

Dans le répertoire src, nous ajoutons notre programme main.cpp. Ce dernier contient les instructions nécessaires pour interroger notre serveur redis via bien sûr hiredis.

#include <hiredis/hiredis.h>

int main(void) {
redisReply *reply;
long int i;

//      For local connections:
redisContext *c = redisConnect("127.0.0.1", 6379);
if (c->err) {
printf("Error: %s\n", c->errstr);
}else{
printf("Connection Made! \n");
}

//    Get all keys for testing
reply = (redisReply *) redisCommand(c, "keys %s", "*");
if ( reply->type == REDIS_REPLY_ERROR )
printf( "Error: %s\n", reply->str );
else if ( reply->type != REDIS_REPLY_ARRAY )
printf( "Unexpected type: %d\n", reply->type );
else {
for ( i=0; i < reply->elements; ++i ){
printf( "Result:%lu: %s\n", i,
reply->element[i]->str );
}
}
printf( "Total Number of Results: %lu\n", i );
freeReplyObject(reply);
}

Dans le fichier CMakeLists.txt, ajouter ce contenu.

cmake_minimum_required(VERSION 2.8)
project(prjredis)
FIND_PACKAGE(HiRedis REQUIRED)
include_directories(${HiRedis_INCLUDE_DIR})
link_directories(${HiRedis_LIBRARY_DIR})

# Sources project
FILE(GLOB MY_SOURCES
src/main.cpp
)

SET (LINKS
${LIBHIREDIS_LIBRARIES}
)

add_executable(prjredis ${MY_SOURCES})
target_link_libraries(
prjredis
${LINKS}
)

Pour compiler notre projet lancer la commande depuis le repertoire build:
cmake ..

puis lancer l’exécutable prj.
./prjredis

Développement OSGi pour serveur Karaf – Part 3

Dans la partie 2, nous avons commencer à mettre en place une application de vente/échange de spiritueux et de vins qui va nous servir de support le la suite des opérations. Cette partie va concerner le module persistance. En effet, pour le moment, notre sauvegarde de données se fait dans une ArrayList ; niveau persistance on a déjà vu mieux! C’est pourquoi nous allons, dans cette partie, mettre en place une solution de type base de données. Personnellement en ce moment, j’aime beaucoup les base de données de type document , mais pour les besoin de l’exemple je vais utiliser une base de données “classique” du genre Oracle, mySQL, postgres, derby, hsql et consorts.

Read more

Développement OSGi pour serveur Karaf – Part 2

Dans la première partie Développement OSGi pour serveur Karaf – Part 1, nous avons vu comment créer un bundle de base et comment le déployer facilement dans Karaf en permettant un redéploiement à la volée en cas de repackaging de notre bundle.

Dans cette partie nous allons mettre en place une logique d’application afin de mettre en place quelques concepts de base.

karaf-logo

Read more

Développement OSGi pour serveur Karaf – Part 1

Ce post est le premier d’une série concernant le développement d’applications OSGi pour Apache Karaf. Apache Karaf est un conteneur OSGi (basé sur Equinox ou Felix au choix).

Read more

PlayN une librairie multi-plateforme pour développer des jeux

Logo PlayN

Quel développeur n’a jamais rêvé de développer son propre jeu vidéo ? Je pense même que la majorité des développeurs s’y sont risqués, que ce soit à leurs instants perdus, ou lors de projets d’étudiants. Toujours est-il que ce rêve d’enfant hante sûrement une majorité d’entre nous.

Nous avons aujourd’hui la chance de vivre une véritable révolution du monde vidéo ludique grâce à l’explosion du marché des smartphones et des tablettes. Le marché du jeu vidéo est en train de changer du tout au tout. Là où il y a quelques années il fallait débourser plusieurs dizaines d’euros pour acheter le moindre jeu vous pouvez maintenant trouver de véritables perles à moins de 1 euro. Les raisons de cette baisse de prix sont multiples, tout à d’abord le nombre de client potentiels à explosé, les temps de développement ont été réduits et de nouveaux mécanismes de paiement sont apparus (publicité, micro paiement in-app, …). Seul point noire à ce nouvel écosystème : la multitude de périphériques existants sur le marché et du coup la segmentation du marché.

Cette diversité contribue bien sûr à dynamiser et à étendre le marché mais il rend le travail des développeurs très compliqué. Il leur faut adapter leurs développements au plus grand nombre d’appareils (même s’ils se contentent en général de l’adapter aux plus vendus). Heureusement il existe aujourd’hui plusieurs frameworks qui permettent de développer facilement un jeu qui tournera sur un grand nombre de plateformes. Je vous propose aujourd’hui de découvrire rapidement l’une d’entre elle : PlayN 1

Présentation

Ce framework est issu du travail de Google, elle permet l’écriture d’application directement compatibles avec Java, Android, HTML5, Chrome, iOS et Flash. L’avantage d’une telle librairie est évidemment la simplicité de portage du code d’une plateforme à une autre. Si vous avez bien travaillé c’est en général transparent.

Afin de travailler avec PlayN il vous faudra :

  • Eclipse
  • Java 1.6+
  • Un client Git
  • Maven 3+
  • Idealement un environnement de développement Android et/ou iOs si vous voulez développer pour mobiles.

L’architecture standard d’un projet PlayN est assez simple. Elle repose sur Maven. Vous avez un projet principal composé de modules. Dans ces modules vous avez un module “core”, qui contient 90% de votre code, et un module par plateforme cible qui contiendra le code spécifique à chacune. En règle général vous n’aurez pas trop à y toucher, PlayN s’occupe de (presque) tout.

L’avantage de l’environnement de développement de PlayN est son côté multi-plateforme. En effet comme PlayN est capable de faire tourner votre code dans un environnement Java vous pourrez tester/debugger votre code directement sur votre ordinateur de développement. Fini les galères de déploiement sur un appareil connecté en USB, la lenteur du remote débuggeur. Bien entendu cela ne vous dispensera pas totalement de tests sur les appareils cibles, mais au moins le gros du travail est effectué sur une machine rapide. Autre avantage non moins important : vous pourrez utiliser tous vos outils habituels pour tester/debugger/profiler vos développements.

Le code

Le développement d’un jeu avec PlayN commence par une classe implémentant l’interface Game. Cette classe contiendra toute la logique de votre jeu dans seulement deux methodes.

En effet lorsqu’un jeu PlayN est demarré une sorte de boucle infinie se lance :

while (true) {
  game.update(...);
  game.paint(...);
}

Vous l’aurez sûrement compris, la méthode update s’occupera de mettre à jour l’état des objets de votre jeu, et la méthode paint dessinera à l’écran ce qu’il y a dessiner.

Une troisième méthode doit être implémentée : <code>public int updateRate();</code>. Cette méthode défini avec quelle période (en ms) vous voulez appeler la méthode update. Attention cela ne définit pas la fréquence des appels à paint. Paint sera toujours appelée aussi souvent que possible. paint et update prennent toutes deux en paramètre un float contenant le temps exact écoulé depuis le dernier appel. Dans paint ceci vous permettra d’interpoler l’état de vos objets entre deux appels à update, et dans update à savoir combien de temps s’est exactement écoulé depuis le dernier appel. Si vous ne faites pas d’interpolation dans paint vous risque de ne pas avoir d’animations fluides. En effet si vous faites du code simulant la chute d’une balle, sans interpolation cette dernière ne sera dessinée qu’aux positions calculées dans la méthode update. Imaginez un balle de 20 pixels de large qui se déplace de 50 pixels à chaque appel à update toutes les 50ms. Dans ce cas vous aurez une balle qui “saute” de 50 pixels en 50 pixels.

Architecture graphique

PlayN étant une libraire destinée à développer des jeux son API sert essentiellement à gérer des graphismes. Pour cela elle découpe l’affichage en couches (Layers). L’API définit un layer de base (root) qui contient une hiérarchie de layers. Les layers sont dessinés de manière automatique par l’API. Les layers peuvent être manipulés de manière simple par des transformations affines (rotations, déformations, déplacements, …).

Il existe plusieurs type de Layers dans PlayN :

  • ImageLayer : un layer représentant une image chargée à partir d’un fichier (PNG, BMP, …)
  • Canvas : un layer représentant une image où vous dessinez à la main (ou juste dessiner à la main)
  • ImmediateLayer : un layer dont le rendu est fait directement dans le framebuffer
  • SurfaceLayer : un layer dont le rendu est fait off-screen puis copié dans le framebuffer

Les contrôles

Tout jeu se doit d’interagir avec l’utilisateur. Pour cela PlayN propose plusieurs mécanismes de contrôles. L’API sait parfaitement gérer un clavier, une souris ou un écran tactile. Pour cela rien de plus simple, il suffit d’utiliser les objets de la classe PlayN correspondants à ce que l’on veut faire : PlayN.pointer(), PlayN.mouse(), PlayN.keyboard() et de jouer avec. L’API se veut assez simple et vous trouverez facilement ce que vous cherchez. Sachez juste que les points d’entrées aux différentes fonctions de l’API sont en général dans la classe PlayN qui n’est grosso-modo qu’un gros réservoir de méthodes statiques.

Conclusion

Si vous voulez réaliser votre vieux rêve d’enfant je vous conseille vivement d’aller jeter un coup d’oeil à cette librairie vraiment bien faite. En quelques heures vous pourrez obtenir vos premiers résultats et peut être même un mini jeu.