Personnaliser ses cartes avec Google Maps API V3

Introduction

Dans le cadre d'un projet que je suis en train de mener, il y a le besoin de représenter une mappemonde avec un certain nombre de pays à mettre en évidence.
C'est un besoin assez classique pour un site web, mais cela peut s’avérer fastidieux et chronophage.
Pour ma part, j'ai rapidement pensé à utiliser l'API de Google Maps. Mais il me fallait styliser ma mappemonde.
Je devrais afficher seulement certains éléments, en l’occurrence seulement les terres et les mers. Mais il me fallait aussi changer les couleurs des mers et des terres, plus autoriser seulement un contrôle réduit sur la mappemonde.
Enfin, pour mettre en évidence les pays souhaités, ceux-ci devaient être affichés dans une couleur particulière et cerise sur le gâteau avec le changement de cette couleur sur l'évènement "onmouseover".

Google Maps API V3

Depuis peu, la version 3 de l'API Google Maps a vu le jour et Google a déclaré la version 2 comme dépréciée. Je me suis donc penché sur cette API.
Tout d'abord, il existe deux façons d'utiliser l'API, soit directement en Javascript, soit avec GWT via le module "Google Maps 1.1 Library". Malheureusement cette dernière ne supporte pas encore la version 3 de l'API Google Maps. Il faudra donc attendre une mise à jour pour bénéficier du confort de GWT.

Dans ce billet, je vais montrer comment utiliser l'API en Javascript. L'API Javascript est bien documentée et très claire. Donc, la première étape est de charge l'API de la manière suivante :



Le paramètre sensor permet d'indiquer s'il faut utiliser la fonctionnalité de géolocalisation du navigateur.
Ensuite, il faut créé l'objet Map en donnant l'élément du DOM qui va recevoir la carte et les options de la carte.



A partir de là on a une carte qui s'affiche positionnée, avec les contrôles que l'on souhaite. Maintenant comment stylisée ma carte ?
Depuis la version 3 de l'API, Google permet la personnalisation complète des cartes au travers de l'API "Styled Maps". Pour appliquer les styles à notre carte, il faut procéder comme ci-dessous :



Maintenant l'opération délicate est de mettre en évidence les pays souhaités. Pour cela on va utiliser un fichier standard KML pour décrire l'emplacement de mes pays sous la forme de polygones. Les polygones sont décrits point à point. On peut trouver des fichiers KML notamment dans les galeries de Google Earth, sinon il existe des outils en ligne pour créer ses propres fichiers KML.
Pour exploiter les fichiers KML dans notre mappemonde, j'ai utilise l'API "geoxml3". Pour cela, il faut importer les librairies suivantes :



Puis les utiliser de la manière suivante :



Le paramètre "useTheData" est une méthode que j'ai définie et qui sera appelée à la fin du chargement de mon fichier KML. Dans cette méthode, je pourrais notamment gérer les évènements de "mouseover" et "mouseout" sur mes polygones comme ceci :



Conclusion

Voila donc une manière élégante et simple de gérer ses cartes, bien entendu ce que je viens de vous montrer n'est que la base. Il est possible de faire beaucoup d'autres personnalisations et d'imaginer des interactions avec la carte beaucoup plus élaborées.

GWT 2.1 RequestFactory : tour du propriétaire

Avec l'arrivée de GWT 2.1, est apparut une nouvelle API nommée RequestFactory. Le but de cette nouvelle API est de simplifier (un peu plus) les échanges entre le client et le serveur.
Les échanges entre le client et le serveur se faisaient traditionnellement avec le mécanisme RPC de GWT. Hors lorsque l'on utilise un ORM et que l'on est dans une architecture "Domain Driven", on se heurte aux problèmes de sérialisations des entités (qui sont des POJO instrumentés).
Plusieurs solutions existent pour palier ce problème : création d'objets DTO, transformation des entités en vrai POJO (avec la librairie Gilead par exemple).
Néanmoins, la mise en place de ces solutions a un coût et il était regrettable de ne pas avoir une solution intégrée par défaut à GWT.
Désormais, c'est chose faite avec l'API RequestFactory. Alors voyons comment fonctionne cette API.

Côté serveur, on va mettre en place une couche de persistance avec JPA. Pour ma part, j'ai choisi Hibernate comme moteur de persistance. Je ne décrirais pas ici la mise en place de cette couche, car ce n'est pas l'objectif de cet article et de nombreux tutoriaux existe à ce sujet. Donc une fois configurée et nos entités créées, puis mappées par annotations, nous allons pouvoir les exploiter avec l'API RequestFactory.

Les entités seront transmissent entre le client et le serveur, sous la forme d'objets DTO sérialisés en Json. C'est objets sont construit par l'API. Mais il faut décrire un minimum ces DTO. Pour cela, il faut créer une interface par entité à transmettre de la manière suivante :




On remarquera que l'on parle de proxy au lieu de DTO, ce qui n'est pas un hasard car la génération de code par defferd binding est très présente (comme dans les mécanismes RPC). D'autre part, il est possible d'utiliser l'API Bean Validation (JSR 303), nous verrons plus loin comment gérer la validation des entités.
Maintenant, on va créer des contextes d'échanges et leur fabrique (RequestFactory) pour le client.

Les contextes d'échanges sont des interfaces qui héritent de RequestContext, elles permettent d'exposer les méthodes statiques de services (un service métier, une DAO, ...) sous la forme d'un objet Request. Elles permettent aussi d'exposer des méthodes d'instance d'objets (une entité, un DTO) sous la forme d'un objet InstanceRequest. Voici deux exemples qui illustre mes propos :





Maintenant il faut créé la fabrique comme ceci :



Désormais tout est prêt, et il faut effectuer les appels côté client. Tout d'abord, on va instancier la fabrique précédemment créée, puis la lier à un EventBus, comme ceci :



Ensuite on va pouvoir récupérer des contextes d'échanges (RequestContext) et faire nos traitements. Voici un exemple de création d'un proxy pour l'entité Employee et l'appel à une méthode statique d'une DAO qui aura en charge de faire persister l'entité :



On voit dans cet exemple qu'il est possible d'avoir un callback sur l’exécution effective de la requête émise par la méthode fire. La méthode onViolation permet de récupérer toutes les violations levées par la validation de l'entité côté serveur.

L'exemple suivant montre comment faire le même traitement mais en invoquant une méthode sur l'instance de l'entité que l'on est en train de créer côté serveur :



C'est là que l'on commence à toucher du doigt le potentiel de cette API ! Je vous laisse le soins d'imaginer comment il est possible de l'exploiter. Voici donc une API qui permet d'augementer encore le rendement les développements GWT , couplé avec les CellWidget cela peut s'avérer redoutable d'efficacité.
Mais cela fera l'objet un d'autre article. Il faudra explorer aussi l'utilisation de cette API avec un conteneur comme Guice ou Spring.

NB :

Lors de mes premiers pas avec l'API RequestFactory, j'ai été confronté à plusieurs problèmes. Le premier est la non compilation des classes avec les annotations @ProxyFor et @Service. Ce problème est lié au plugin Eclipse GWT Designer, le seul contournement que j'ai trouvé est de désinstaller le plugin... Espérons que les prochaines mises à jour du plugin réglera ce problème. Le second problème que j'ai rencontré est de bien veiller à utiliser l'annotation @Id du package javax.persistence dans les entités JPA et ne pas utiliser l'annotation @Id du package com.google.gwt.requestfactory.shared.

Changement de travail

Après six années de bons et loyaux services pour la société Hinnoya, j'ai décidé d'aller relever de nouveaux défis technologiques au sein de la société Silverpeas.
Voici quelques informations sur Silverpeas :

Silverpeas développe une solution de portail collaboratif. Cette solution est Open source sous licence Gnu Affero GPL V3. Le portail Silverpeas est entièrement développé avec la technologie Java.

GWT the Google master piece

Le compilateur GWT est très puissant et modulaire. J'ai déjà parlé du mécanisme de deffered binding qui permet de générer ou substituer du code Java avant sa compilation en Javascript.
Mais il existe un autre moyen d'exploiter le compilateur, il s'agit d'exploiter les Linkers.
Les linkers interviennent après la compilation et sont en mesure de modifier les fichiers générées pour adapter l'application à son contexte d’exécution pas exemple. Le linker par défaut est IFrameLinker, ce qui a pour résultat de générer une iFrame cachée. GWT propose d'autres linkers : SingleScriptLinker, XSLinker, SymbolMapLinker, SoycReportLinker.
Mais l'on peut trouver un linker pour créer des extensions pour Google Chrome, ou FireFox.
Il est bien entendu possible de créer d'autres linkers personnalisés. Alors on peut imaginer de nombreuses adaptations/intégrations pour le code GWT (Portlet, Gadget, Native client, Chrome OS, ...).
C'est pourquoi GWT semble devenir de jour en jour la couche d'abstraction générique de Google. GWT pourrait donc devenir la pièce maîtresse de Google au niveau du développement de ses applications/services.

Reparlons-en dans deux/trois ans ;-)

Gestion des skins et ClientBundle

With GWT 2.0 ClientBundle appeared. This mechanism is very interesting because it optimize the loading time of a web application resources, such as CSS files, images files, and many others.
This mechanism also allows typing of CSS using Java interfaces to access styles; The compiler verifies the existence of CSS classes used.
To do this, simply declare an interface that inherits CssResource and define methods corresponding to names of CSS classes.
To inject the CSS in the HTML page is then necessary to generate an instance of the CSS resource through : GWT.create (MyCSSResource.class). Then call the method "ensureInjected ()" on this instance.

This mechanism works very well, now let us see how to manage skin with this mechanism.

The idea is to change style sheet dynamically. The HTML page elements remain unchanged and refer to the same CSS classes.

For this, we can use the inheritance mechanism between interfaces CssRessources to structure CSS skins. To have identical CSS class names, do not forget to add the annotation @Shared on parent interface.

To inject the selected CSS skin, do not use the method "ensureInjected ()" because it controls the injection of resources and CSS will injected only once. Should be used instead : StyleInjector.inject (cssStyle.getText ())

But not to overload the page, we must removing the contents of the previous CSS, stored in the header of the page.

Here an example of code :

To make dynamic discovery of skins, we can use a generator (see previous article).

Stay tuned

GWT and reflexion API

As you probably know, GWT does not emulate the reflection API of Java. It is a conscious choice by Google, which is motivated by the performance degradation induced by the introduction of mechanisms for reflection (not mentioned the lack of control of code).
However, it is sometimes useful to use the reflection API. Recently, I was confronted with the establishment of a GWT application that handles plugins. These plugins must be discovered dynamically. In Java you would use a scan packages with the reflection API or with Spring IOC. But in my case it is not possible because there are plugins that are client side, so that must comply with the constraints of GWT.

So how can i do that ?

To overcome this problem, the GWT team has developed the mechanism called "deffered binding" that allows to perform operations before the compilation of Java code in Javascript.
For my problem, I used a Generator. The generator, as its name suggests will allow to dynamically generate Java code before compiling for a given type.

What is interesting is that at this stage, it is possible to use any Java API that is desired because the generator is running in a JVM.
We can therefore use the reflection API. Furthermore, the scanning of packages is possible because the classes corresponding to the project source code is loaded into the classloader.
Once obtained the list of plugins (a plugin implements an interface call "Plugin"), it must generate a list of plugin object with an object through PluginFactory generator.

On this occasion, I also discovered a very nice API to list the packages in the ClassPath: classpath-explorer

So here we are an elegant technique to develop a plugin mechanism with GWT. The only drawback to this method is that for the addition of a plugin, it is necessary to recompile the project, which is not needed with Java plugins (like Eclipse plugins).

GWT 2.1 : les nouveautés

Depuis le 02/07/2010, GWT 2.1 milestone 2 est disponible.
La première release devrait être mise à disposition par Google pour la rentrée en Septembre. Mais qu'apportera cette nouvelle version, faut-il attendre cette prochaine version avant de démarrer le développement d'une nouvelle application ?
C'est à ces questions que je m'efforcer de répondre.

Ce qui est marquant avec cette nouvelle version, c'est la quantité de code produite par l'équipe de Google. Car entre la version 2.0.3 et la version 2.1, il y a environ 20 % de code en plus au niveau de la framework (gwt-user).

Tout d'abord, cette nouvelle version apporte de nouveaux composants orientés données (data presentation widgets). Il y a par exemple le composant liste paginable.
En fait, il s'agit de l'apparition des composants avec un modèle associé. Il y a un modèle pour les listes, pour les listes paginées, pour les arbres, pour les composants avec sélection simple ou multiple.
On voit aussi l'apparition d'une gestion plus fine des tableaux, avec la possibilité de spécialiser des cellules (cellule de saisie pour un certain type de données, affichage selon un format...).
Cette nouvelle version devrait apporter des solutions à des problématiques communes, avec notamment une implémentation du pattern "service place", mais aussi une implémentation du pattern MVP (Model View Presenter) avec un système de validation des formulaire déclaratif au niveau de l'UIbinder.
Il y a même un mécanisme de synchronisation des objets entre client et serveur (valuestore). Ce mécanisme est plutôt original, et alimente de nombreuses discutions aux seins des contributeurs, il n'est donc pas certain que ce dernier soit présent dans la release 2.1.

Ensuite, il y a de nombreuses classes et mécanismes utilitaires qui seront ajoutés, tel que la compression des échanges RPC avec l'algorithme gzip. Des classes utilitaires de gestion des expressions régulières font leur apparition.

Et enfin, un un système de logs côté client est intégré afin d'exploiter l'émulation de la stack trace. Ce système de logs ressemble beaucoup au module gwt-log créé par Fred Sauer.

Avec cette nouvelle version, on constate que l'effort de l'équipe GWT pour rendre de framework encore plus mature est constant.
Alors faut-il attendre la version 2.1 de GWT avant de démarrer un nouveau développement avec cette technologie ? Et bien, que non. Il faut bien choisir les modules complémentaire, par exemple pour la gestion des logs. La mise en application de patterns comme le MVP ou le "service place" structurera l'application et facilitera la migration vers la future implémentation de GWT. Vous avez donc bien compris que Google s'inspire des différents projets maintenus par la communauté, mais aussi des retours d'expériences sur GWT.
La dynamique de Google est forte sur le projet GWT, il faut donc s'assurer de rester agile. En s'informant (Google donne beaucoup d'informations) et un peu de recule, les orientations et choix à faire se dégagent.

Pour vous donner un avant goût de la suite, la version suivante de GWT (la version 2.2) devrait apporter des évolutions non négligeables, avec notamment, le début de prise en compte de l'HTML5.

Stay tuned.

Sweet home 3D

J'ai découvert récemment un petit logiciel assez bluffant, nommé "Sweet home 3D". Ce logiciel de conception de plan 2D et 3D est totalement écrit en Java et est publié sous la licence GNU.
Pour utiliser ce logiciel nulle besoin d'avoir des connaissances pointues en DAO/CAO, il est très facile de prise en main et est très productif.
Avec  "Sweet home 3D", il est possible de :

• dessiner les pièces
• dessiner les murs des pièces par dessus l’image d’un plan existant
• créer et éditer les côtes dans le plan
• glisser-déposer ses meubles dans le plan à partir d’un catalogue organisé par catégories
• importer ses propres modèles 3D dans le catalogue
• exporter les objets de la vue en 3D au format OBJ
• imprimer, exporter au format PDF, SVG

Ce qui est très agréable avec ce logiciel, c'est l'on visualise les modifications du plan en temps réel dans la vue en 3D, soit en vue aérienne, soit du point de vue d’un visiteur virtuel.

En conclusion, "Sweet home 3D" est à connaissance le seul logiciel libre aussi facile d'utilisation et aussi bien fini de sa catégorie. Bien sûr, il manque encore quelques fonctionnalités telle que la gestion des étages. Mais ce n'empêche en rien de l'utiliser et de concevoir des logements très réalistes.

Lyon en 3D

J'utilise très souvent Google Maps et notamment Google Street View. Il y a environ six mois je découvrais que la couverture de Google Street View en France avait progressé de manière impressionnant (plus de 70% du territoire est couvert). Ce service est tellement pratique et accessible, que j'en avais oublié Google Earth. Récemment, j'ai relancer "par hasard" Google Earth. Je connaissais la fonction "Bâtiment 3D" et l'avais donc précédemment activé. Et là, j'ai eu la surprise de découvrir la ville de Lyon entièrement modélisée en 3D.

On peut zoomer sur les façades, changer l'angle d'inclinaison, tourner autour des bâtiments. La précision est remarquable et le nombre de bâtiments modélisés est tout simplement énorme. Par contre, pour profiter pleinement de cette fonctionnalité il faut avoir une bonne connexion internet (une connexion fibre optique devrait pleinement s'exprimer).

GWT s'ouvre et s'intègre

J'avais précédemment parlé de l'industrialisation de GWT, la semaine dernière a vu naitre la version 1.3 du plugin Eclipse de GWT. Cette nouvelles version du plugin est importante car elle permet l'utilisation des projets Dynamic Web d'Eclipse. Ce qui signifie une plus grande souplesse dans l'organisation des développements et la promesse d'une meilleures intégration avec Maven.
Les développements GWT vont donc se fondre dans les processus de développements JEE, ce qui devrait favoriser son adoption au sein de la communauté Java.

Strong typing in web application

Lorsque je s'écrire un programme, j'ai horreur d'avoir des surprises au moment de l'exécution du programme (at runtime). Pour palier à ces mauvaises surprises, il faut d'abord compiler le programme. Celui-ci va effectuer des vérifications et donc éviter d'avoir de mauvaises surprises à l'exécution du programme.

Cela dit, pour assurer une vérification optimale de la part du compilateur, il faut avoir recours à un typage fort.

Maintenant, imaginez que l'on puisse appliquer ces principes avec des  développements web. Car lorsque l'on développe une application web, c'est généralement tout l'inverse. En effet, le web est traditionnellement une technologie runtime (ex : PHP, JSP, ASP, javascript, ...). Qui n'a pas eu a faire à l'erreur HTTP 500 ? Ou bien à des mises en formes cassées suite à une réorganisation des fichiers CSS ?

Vous l'avez compris, les développements web sont souvent délicats à tester car nous manipulons plusieurs technologies runtime.

En plus, des bugs générés par cet état de fait, il y a une autre incidence à cela; J'ai nommé la productivité, c'est pourquoi le scaffolding a le vent en poupe ces derniers temps. Le code généré est fiable et vite obtenu. Mais cette technique n'est qu'un pisalé, car inévitablement il faudra retoucher le code généré un moment donné, et là on retrouve les problèmes que j'ai précédemment cité.

Alors, existe-t-il une solution qui permet de développer des applications web, avec une compilation préalable ? Et bien oui, il s'agit de Google Web Toolkit. Depuis la version 2.0 de GWT, il est possible de compiler l'HTML et le Javascript, mais aussi le CSS  et les ressources (images, textes, documents, ...).

Et même en utilisant le UI-binder, le compilateur garantie que toutes les vérifications nécessaires seront réalisées. Par exemple, si un style CSS est référencé dans un composant et qu'il n'existe pas, alors le compilateur signalera une erreur. Avec ce simple exemple, on comprend très vite que GWT permet non seulement de réaliser des applications fiables, mais aussi de manière rapide.

MyColocation

Aujourd'hui est en grand jour (pour moi), je viens de mettre en ligne la première version de mon application "MyColocation". L'objectif de cette application est de permettre la gestion quotidienne d'une colocation. Dans cette version je me suis essentiellement attaché a gérer les tâches qui incombent aux colocataires. Cela signifie, identifier les tâches, mais aussi les répartir de manière collaborative, et les suivre.

Du côté de l'ergonomie, j'ai essayé de rendre l'application la plus simple. J'ai donc naturellement eu recours au Drag&Drop.

Cette application est entièrement écrite avec GWT 2.0.3 et les API de GAE 1.3.1. Je trouve que mes développements ont été relativement productifs.

Cela est dû à la productivité engendrée par GWT 2 (Uibinder et Dev mode), mais aussi à la grande facilité d'utilisation d'App Engine. En effet, il est possible de développer et tester localement son application, avant de la déployer sur le Cloud. La gestion des versions est plutôt bien pensée et la console d'administration est plutôt riche.

Le seul point négatif que j'ai pu noter, est les limitations imposés par Google au niveau du DataStore et en particulier le support limité de JPA. L'apparition récente des curseurs, me laisse espérer que ces limitations vont progressivement disparaitre.

Pour vous faire une idée de cette application, je vous invite à vous rendre à l'adresse suivante : mycolocation.

N'hésitez pas à me faire des suggestions d'améliorations, je ferais mon possible pour en tenir compte.

GWT 2.0.2 est là : Google très réactif

Depuis la sortie de la version 2.0 de GWT, on assiste à une adoption de la plus en plus large de GWT en France et les migrations de GWT 1.x à 2.0 se succèdent. Dans le même temps, tout un écosystème s'est mis en place autour du toolkit : plugin eclipse, speedtracer, plugin browser for devmode, ...
D'autre part, la réactivité de l'équipe Google est de plus en plus visible : depuis la version 2.0 sortie en décembre 2009, deux versions correctives ont vues le jour (version actuelle 2.0.2). Et Google ne compte pas s'arrêter en chemin; Pour preuve, Bruce Johnson (le responsable du projet GWT), a fait des appels du pied récemment à la communauté, pour que des développeurs rejoignent l'équipe GWT  à Atlanta.
Tout ces éléments me font dire, que GWT est en train de monter en puissance et de s'industrialiser. Google vise clairement le marché des entreprises avec GWT, comme il est entrain de le faire avec sa suite Google Apps.
Cela promet, donc une année 2010 riche en nouveautés et en projets d'entreprise.


Pour ma part, je travaille actuellement sur un projet GWT App Engine dont je vous donnerais des nouvelles très bientôt.

"Wicket with GWT" and not "GWT vs Wicket"

Often, we compare Wicket vs GWT because they are both component-oriented. But the comparison stop there, because their approaches are opposed. Wicket is oriented server : the server generates web page. While GWT is client-oriented : the client is downloaded and communicates with the server.

Wicket ajax components are based on javascript libraries. This does not facilitate the development and maintenance of these components (using multiple libraries, the problem of multi-browser compatibility, web page size, ...).

GWT applications are oriented RIA, which is quite different from a "classic" web application and the user may be a little disoriented ("back / next" navigation, refresh browser, single mode page ...).

So why not combine the power of GWT with that of Wicket to create original web applications ?

Here is an article which proposes an architecture for combining the best of both worlds. Unfortunately, since 2008 it does not appear to have been implemented. In fact we can solved this equation with only GWT.

The single page mode that can disrupt the user. For this it is possible to create HTML pages which embed the javascript application generated by GWT. Each page is composed of area identified by ids, which are injected components of the GWT application (using RootPanel.get(id).add(myComponent)).

Navigating between pages is provided by :

public static native void setWindowHref(String url)/*-{ $wnd.location.href = url; }-*/;

In this configuration, the client becomes stateless (like a "classic" web application). But the components are more dynamic (as an application RIA). This approach may be useful in some cases to meet the requirements of users and do not change their habits.

Android Phone plutôt qu'iPhone

Voici un post pourquoi expliquer pourquoi je n'achèterais pas un iPhone mais plutôt un Android Phone. Mon argumentaire s'articule autour de cinq points que voici :

• La liberté : Android est un système base sur le noyau Linux, il n'est pas la propriété d'une entreprise unique (licence Apache 2.0). Je trouve cela rassurant, mais au-delà de cette sensation cela a d'autres avantages comme ne pas avoir un verrouillage du système, et possibilité de changer facilement de système.

• La diversité : Avoir le choix du matériel me semble vital. On choisit un téléphone qui correspond à nos poches, nos attentes. Alors qu'avec l'iPhone c'est "taille unique".

• Les applications : Alors c'est vraiment que Apple Store compte plus d'applications que Android Market, mais les applications "cools" existent sur Android Market (Seesmic, Spotify, ...). Des applications sont désormais développées pour Android avant de l'être pour iPhone. Enfin, je pense que le débat des applications est un faux débat, car les applications seront majoritairement web dans l'avenir (donc multi-système).

• Le multitâches : Android supporte nativement le multitâches contrairement à l'iPhone qui autorise le multitâche que pour les applications Apple.

• Le nuage : Avec Google Apps plus besoin d'effectuer les fastidieuses synchronisation entre ordinateurs de tous poils et le smartphone .

Cela dit, je pense que l'iPhone est un très bon produit mais Apple n'a pas le monopole des idées et notamment en ce qui concerne les smartphones. Il ne faut pas oublier les autres acteurs innovants du marché qui sont entre autres Google, Nokia, Samsung...

Richard Stallman en France

En ce début d'année, Richard Stallman que l'on ne présente plus, est de passage en France pour défendre le logiciel libre. Après avoir donné une conférence à Paris, le voici à Grenoble.

J'ai eu la chance d'assister à cette conférence qui a attirée plus de 650 personnes. Son charisme captive littéralement l'assemblée.

Pour lui, le bilan de l'initiative GNU est plutôt positif : GNU marche assez bien aujourd'hui avec le noyau Linux. Cependant, il considère que le logiciel libre reste à promouvoir, car la grande majorité des utilisateurs est toujours sous l'emprise d'éditeurs de logiciels comme Microsoft, Apple et bien d'autres. D'autant qu'il existe un millier de distributions Linux, mais que rares sont celles qui sont entièrement à base de licences GNU comme Ututo ou gNewSence (voir la liste sur le site de GNU).

Le reste de la conférence est plus philosophique que technique. Le terme "privateur" est employé pour désigner les logiciels non libre, plutôt que "propriétaire" ou "privatif". Selon lui le terme "privateur" ne dissimule pas la vrai nature de ces logiciels : les logiciels privateurs privent les utilisateurs de leur liberté.

Le parallèle entre les droits de l'homme et la notion de logiciel libre est fait : "un logiciel libre c'est un logiciel qui respecte la liberté de l'utilisateur". Rien a voir avec la notion de gratuité. Il ne s'agit pas non plus de la possibilité d'obtenir le code source du logiciel. C'est la possibilité de changer de logiciel, de changer le logiciel, d'être écouté et de ne pas être enfermé dans un mode de pensé unique. "Open source ne signifie pas libre". A ses dire, ce terme a été créé de toutes pièces en 1998 par les entreprises qui fabriques des logiciels privateurs, afin de tromper les utilisateurs. Le code est téléchargeable, mais ces entreprises ne tiennent pas compte des remarques des utilisateurs. Mais le plus grave est que ces entreprises s'immiscent dans la vie de l'utilisateur dès le plus jeune âge, car les écoles reçoivent des logiciels privateur gratuitement. Le secteur de l'éducation a le devoir de protéger les élèves d'un enfermement intellectuel et pour cela ne devrait utiliser que des logiciels libres. 

Il fait ensuite référence aux détracteurs du logiciel libre, qui disent que ce modèle n'est pas économiquement viable et que cela génèrerait des pertes d'emplois. Selon lui, un monde uniquement libre ne causerait très peu de pertes d'emplois, car la très grande majorité des logiciels existants sont des logiciels "sur mesure". Les logiciels privateurs représentent qu'une petites parties des logiciels. De plus, pour lui dans le cadre d'un développement d'un logiciel sur mesure pour une entreprise, il est normal qu'un développeur se fasse rémunéré. Par contre, les logiciels d'intérêts généraux doivent être libre (traitements de textes, système d'exploitation, navigateur internet, ...).

Richard Stallman aborde le sujet de la qualité des logiciels libres en indiquant que certains disent que le libre est meilleur car sa qualité technique est supérieure à celle du logiciel privateur. Pour lui c'est un détail secondaire. Et ce n'est pas toujours le cas. Ce qui est important c'est que le logiciel libre soit éthiquement supérieur.

Voila donc un recadrage de ce qu'est le logiciel libre, car il est vrai que beaucoup de personnes parle d'Open source et de logiciels libres, mais les fondamentaux ne sont pas connu ou ont été détournés au fil du temps.

GWT incubator integration roadmap

Depuis ce début d'années, Google réfléchit à la suite de GWT 2.0. Bruce Johnson sonde la communauté afin de connaitre les attentes des développeurs.

Et aujourd'hui on commence à avoir des informations sur la roadmap de GWT 2.1 et 2.2 (voir ici). Bien entendu pour le moment il n'y a rien d'officiel. Cela montre tout de même que l'équipe qui développe GWT ne s'endort pas sur se lauriers (après l'énorme travaille fournit pour passé de la version 1.7.1 à 2.0) et que GWT est plus vivant que jamais.

Pour ma part, je suis particulière sensible à l'intégration d'un système de validation des formulaires. J'espère que ce système sera conforme à la JSR-303 et qu'il permettra de tirer parti de la validation des formulaire avec HTML5 (si le navigateur le support).

Affaire à suivre...

Virtual server with VirtualBox

The virtualization solution "VirtualBox" by Sun is very simple to implement and efficient. 

It is possible to run virtual machines in headless mode, ie accessible by remote display. Regarding connectivity of virtual machines it is possible to use the NAT mode or implement an bridged interface.

I use Virtualbox this way on a server, that works without being stopped last year. I have found no problems, so I think VirtualBox is a real alternative to other virtualization solutions. Especially since the last version of VirtualBox allows to switch virtual machines to another host without interrupt service  (teleport functionality).

The virtual machines launch in headless mode is done by command line, which may be repulsive for neophyte; Fortunately there is a project called "vboxweb" which provides the equivalent of the VirtualBox console, but in web mode with virtual machines launch in Headless mode. All features are not implemented yet but the project seems promising and active.

Affiches publicitaires de Google Chrome

En ce début d'année 2010, on assiste à l'apparition d'affiches publicitaires pour Google Chrome, notamment dans le métro Parisien.

Je pense que c'est la première fois (en France) que Google procède de la sorte et change sa façon de faire de la publicité. Jusqu'ici le seul média utilisé par Google était le Web.

Bien sûr il y a les spots publicitaire sur les chaines de télévision pour les mobiles Androîd, mais il s'agit de publicité indirect car c'est les constructeurs de mobile qui sont a l'origine de ces publicités.
Mais cette fois-ci il s'agit bien d'une publicité "non électronique" pour une produit de la société Google.
On peut donc se poser la question : pourquoi ce changement ?

Cela ne présage t-il pas de changements plus profonds ? Que vont apporter ces changements ? Une nouvelle aire pour Google? Pour les internautes ? Pour l'innovation informatique ?

En tout cas, cela ne laissera personne indifférent et cela va faire couler beaucoup d'encre...

Happy New Year !

Happy New Year for everyone.
I want to send best wishes for a great New Year.
Hope all of you had a great evening of celebration.
Embrace and enjoy the coming challenges and possibilities !