Il y a des astuces que j’estime devoir propager sur Internet, car ça peut éviter quelques arrachages de cheveux.

Symptôme: quand on souhaite démarrer IIS (6), ce dernier plante avec l’erreur “Une erreur 0×8ffe2740 inattendue s’est produite“.

Le nom de l’erreur n’est pas très clair, et je me suis dit que le numéro hexa serait différent pour chaque PC. Mais j’ai finis par chercher ce numéro sur Google et je suis tombé sur l’explication: http://support.microsoft.com/kb/816944/fr

Pour résumer, le port utiliser par IIS (80 par défaut) est déjà utilisé.
Le port 80?? Mais qu’est-ce qui peut bien utiliser le port 80 sur mon PC fraichement installé???!!

Le site de Microsoft conseille d’utiliser 2 outils pour trouver le fautif: TCPView qui est une application “graphique”, et FPort qui est en ligne de commande. Bien sûr, je choisi la version “graphique”, sympa d’ailleurs mais qui ne trouve pas le fautif!!
Heureuse FPort, quand à lui, a bien trouver l’application qui utilise le port 80:

Et oui, le fautif c’est Skype! Très étonnant… info trouvé sur http://forum.skype.com/index.php?showtopic=42531

Donc voila ce qu’il faut décocher pour corriger le problème:

La plateforme .Net fournit un mécanisme pour gérer les paramétrages. Il en existe 2 types : ceux de l’application et ceux de l’utilisateur. Au début de l’existance, il y avait la bonne vielle méthode du fichier *.ini, mais aujourd’hui le XML et devenu LE standard pour écrire des données dans un fichier “lisible” et structuré.

Il existe un autre standard : les applications .Net possède un fichier “mon_application.exe.config” qui n’est autre qu’un XML contenant le paramétrage de l’appliation. Ce fichier est structuré en 2 grosses parties: l’entête avec la section “configSections” qui décrit les sections du XML et les “parser” qui vont lire ces dernières. Puis il y a les sections proprement dites.

Quand on veut utiliser des settings de l’application de type “clef=valeur”, on peut les renseigner dans la section “applicationSettings”. On peut ainsi facilement créer un paramétrage de l’application mais aussi pour chaque utilisateur à l’aide de la section “userSettings”.
Voici un exemple de paramétrage:

<userSettings>
	<MonApp.Settings>
		<setting name="PreferredLanguage" serializeAs="String">
			<value>fr-FR</value>
		</setting>
	</MonApp.Settings>
</userSettings>
<applicationSettings>
	<MonApp.Settings>
		<setting name="TimeShowMsg" serializeAs="String">
			<value>5</value>
		</setting>
		<setting name="NotepadPath" serializeAs="String">
			<value>c:\windows\notepad.exe</value>
		</setting>
	</MonApp.Settings>
</applicationSettings>

VisualStudio propose une technique simple pour manipuler ces paramétrage. Il permet de créer un fichier “.settings” qui va tout simplement générer une classe pour accéder à tout ça, et qui va aussi permettre de sauvegarder les settings de l’utilisateur courant (dans un .config séparé dans C:\Documents and Settings\UserName\Local Settings\AppName\).

// on récupère la valeur d'une clef très simplement
String value = Settings.Default.MyKey;
// si elle a comme scope "user", on peut la modifier et la sauvegarder
Settings.Default.MyKey= value;
Settings.Default.Save();

Pour ma part, j’utilise massivement Spring.net et ses XML. Mes objets possèdent souvent des attributs qui ressemble à des paramètres (j’externalise au maximum). De plus, Spring.net propose de référencer d’autre XML, ce qui me permet de découper mon paramétrage en plusieurs fichiers pour différent domaine (Logging, Base de données, etc).

<!-- dans le App.config -->
<objects xmlns="http://www.springframework.net">
  <import resource="logging.xml"/>
  <import resource="database.xml"/>;
  <import resource="general.xml"/>
</objects>

<!-- dans general.xml -->
<objects xmlns="http://www.springframework.net">
  <object id="Setting" type="MonApp.Setting, MonApp">
    <property name="Timeout" value="100"/>
  </object>
</objects>

Mais il est vrai qu’un XML de Spring n’est pas facile à lire, car il ressemble à un code C# avec une suite de construction de classes. Il peut devenir vite complexe s’il y a beaucoup de classes de relations entre eux, ou si on utilise des concepts avancés de Spring.net (ObjectFactory par exemple).

Une des solutions les plus élégante pour un public informaticien, est de créer ses propres balises XML Spring.net, comme celles déjà existantes (Exemple: paramétrage de base de données.) On masque ainsi la complexité de la construction du programme en laissant une grande souplesse. Mais cette solution demande un certain effort dans la réalisation du parser XML.

<objects xmlns='http://www.springframework.net'
             xmlns:custom="http://www.grozeillle.com/custom">
  <custom:Setting timeout="100">
    <custom:EmbededSetting name="Default">
      <!-- autres settings -->
    </custom:EmbededSetting/>
  </custom:Setting>
</objects>

Mais ces fichiers de paramétrages restent difficiles à lire pour une personne non-informaticienne, qui n’a pas besoin de savoir comment le programme est construit. Dans ce cas, on externalise des valeurs dans des fichiers “.properties” très lisible puisque c’est une simple fichier texte avec une liste de couples “clef=valeur”. On peut aussi externaliser ces couples dans une XML mais on perd l’intérêt d’avoir quelque chose de très facile à lire.

<objects xmlns='http://www.springframework.net'>
<!-- Cet objet contient une liste de "fournisseur" de paramétres-->
  <object type="Spring.Objects.Factory.Config.VariablePlaceholderConfigurer, Spring.Core">
	<property name="VariableSources">
	  <list>
		<!-- Nous n'avons ici qu'un seul fournisseur,
			qui va chercher les paramétrages dans un fichier .properties -->
		<object type="Spring.Objects.Factory.Config.PropertyFileVariableSource, Spring.Core">
		  <!- la liste de nos fichiers .properties -->
		  <property name="Locations">
			<list>
			  <value>config.properties</value>
			</list>
		  </property>
		</object>
	  </list>
	</property>
  </object>
</objects>

On peut ainsi utiliser des variables comme ceci:

<objects xmlns='http://www.springframework.net'>
	<!-- mon object de type "MyTutoClass" a besoin du chemin de Notepad.exe -->
	<object type="MyApp.MyTutoClass, MyApp">
		<property name="NotepadPath" value="${notepad.path}">
	</object>
</objects>

Mon fichier .properties ressemble simplement à ça:

;ceci est un commentaire
notepad.path=c:\windows\notepad.exe

Spring.net propose plusieurs méthodes de recherche de ces clef+valeur. On peut avoir comme source des fichiers “.properties”, mais aussi la section “settings” dans l’App.config (comme vu plus haut), la base de Registre, etc. Voici la liste dans la documentation officiel. Si elle ne vous suffit pas, vous pouvez toujours créer votre “provider” vous même.

Enfin, pour les plus “hardcore” d’entre-vous (ceux qui aime recoder l’univers), vous pouvez aussi créer votre propre XML avec votre propre format. Il est vrai qu’on souhaite parfois faire sa propre classe “Setting” car on veut hiérarchiser les différents paramètres. Admettons que l’on veuille vraiment avoir son propre format de fichier XML, ceci reste très simple en .Net:

// créer un "serializer" de Setting
XmlSerializer serializer = new XmlSerializer(typeof(Setting));
// création d'un flux sur mon fichier XML
TextWriter writer = new StreamWriter("Settings.xml");
// création de ma classe de Setting
Setting setting = new Setting();
// setting.Timeout = 5; etc, etc..
// enfin, sauvegarde de mon objet sous format XML dans le flux de mon fichier "Settings.xml"
serializer.Serialize(writer, setting);

On ne peut pas faire plus simple, non? Et vous savez quoi? Par défaut, ça marche sans rien faire d’autre. Mais si vous voulez customizer le format du XML, il suffira de décorer notre classe Setting à l’aide de quelques attributs [XmlAttribute]. Si vous voulez générer un schéma XSD de ce format XML, c’est à l’aide de c:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\xsd.exe.

Enfin, après une longue attente, de nombreuses hésitations, l’iMac illumine mon salon!

A chaud voici mes premières impressions:

• C’est beau, la dessus on est tous d’accord. Le packaging est de qualité, l’objet en lui même est magnifique, et MacOSX est sublime. Même des applications “classiques” comme Firefox sont beaucoup plus belles/ergonomiques. On voit que tous les développeur Mac font un effort particulier dans le domaine.

• MacOSX c’est pratique. Je n’ai aucun problème à trouver quoique ce soit. Tout est à porté de click, c’est vraiment l’informatique à porté de tous, et c’est très agréable, voir reposant. Vous ne le savez peut-être pas, mais les applications ne s’installent pas avec un Setup comme sous Windows. Chaque application est un dossier avec son icon perso. Ce dossier contient tous les fichiers de l’application, et un double-click sur le dossier lance l’application. Quand on télécharge une application, on récupère un .dmg (une image ISO) qu’on “monte” (avec un simple double-click). Cette dernière possède souvent une apparence de dossier personnalisée et l’installation du logiciel se fait à l’aide d’un simple “glisser/déposer” de l’icon de l’application dans le dossier “Application”. Voici plusieurs exemples.

• C’est fluide. MacOS avec ses effets de fondu donne une impression encore plus grande de fluidité. Les jeux sont fluide aussi: j’ai testé WOW sous Mac, la démo de Quake4 toujours sous Mac, mais aussi Unreal Tournament 3 sous Windows: En 1900×1200 j’ai de très bonnes perfs (entre 60fps et 38fps, et en activant la synchro verticale je fait en moyenne du 50fps).

• C’est grand. L’écran est tellement grand (1900×1200) que je me suis rendu compte que j’étais assis à gauche de mon bureau est que je ne regarde qu’un morceau de l’écran. Je dois tourner la tête pour voir l’autre coté, ou prendre du recule! En tout cas, avec la télécommande de FrontRow et le cul posé dans le canapé, c’est un vrai bonheur.

• Le clavier plat “à la portable” est très agréable et silencieux. La souris sans fil est légère et précise.

Tout n’est pas rose non plus, voici mes premières impressions négatives:

• Les touches du clavier ne sont pas “standard”. C’est très troublant d’avoir le ‘!’ avec ’shift+8′ ou ce genre de changement… je ne sais toujours pas ou trouver l’anti-slash.

• Les raccourcies sont très différents sous MacOS. J’ai buté pour trouver comment supprimer des fichiers (cmd+backspace) et je me fait piégé souvent avec le ‘ctrl+flèche’ qui me change de bureau (sous windows/linux je m’en sert pour déplacer le cursor de mot-en-mot). La touche ‘fin’ va à la fin du document et je n’ai pas encore trouvé comment aller à la fin de la ligne. Ceci dit, je m’habitue vite (comme pour le ‘cmd+c’ pour copier et non ‘ctrl+c’)

• La mightymouse: petite, jolie, agréable, mais elle n’est pas parfaite. Les clicks ‘latéraux’ sont très très dure (je vais me muscler les doigts). Elle supporte le click-droit (qui est désactiver par défaut -_-’) mais étant “tactile” il détecte parfois un click-gauche. Pour être sûr de faire un click-droit, il faut lever le doigt du click-gauche ou utiliser le raccourcie ‘ctrl+click’.

• Au début j’ai trouvé que le son était pas mal. Mais au bout d’un moment, j’avais une sensation d’être dans une grande salle qui résonne ou à un concert. J’ai vite remis mes enceintes.

Je ne peux pas dire que c’est un vrai point négatif, mais j’ai passé beaucoup de temps à installer Windows XP. Bootcamp est très facile à utiliser, il partitionne très bien et très vite (et propose une taille correcte par défaut). Mais mon XP est vieux, et n’inclue pas le SP2 de base. Un XP sans SP2 ce n’est pas supporté officiellement. A cause de ça, le setup des drivers du CD de Bootcamp ne voulais pas s’installer. J’ai alors installé de nombreux drivers à la main, mais sans le SP2 certains ne fonctionnaient pas.

Installer le SP2 sur un XP installé avec Bootcamp, c’est l’horreur. En effet, ce dernier ne voulais pas s’installer car il me disait que je n’avais pas assez de place sur mon disk: il me demandait toujours 4mo supplémentaire. Il n’y a pas beaucoup d’aide sur les forums à ce sujet, mais j’y finis pas trouver la solution en googlant: il fallait créer une clefs de registre à la main car l’installation ne l’a pas faite (info trouvé ici). Cette infos sera utile pour ceux qui veulent installer le SP3.

En conclusion:

En tant que développeur, certains raccourcies clavier me gênent. J’ai donc quelque problème d’adaptation mais ça ira avec le temps. Sous Windows, les raccourcies me sont connus mais les touches “non standard” demeurent.
J’ai du mal à m’habituer au fameux click-droit de la souris, mais après avoir testé la démo de Unreal Tournament 3, je me suis rendu compte que mon ancienne souris n’est pas mieux. En passant à l’ancien clavier et l’ancienne souris, je perds en précision, les touches du clavier sont dure et j’ai du mal à me déplacer, etc. Donc finalement, ce n’est pas si mal, j’ai juste besoin d’un temps d’adaptation.

Windows avec Bootcamp fonctionne bien (après quelque galère à l’installation car je n’avais pas un SP2…). J’ai hâte d’installer Linux et voir ce que ça donne avec Compiz.

Au final, j’en suis très content. J’ai un PC rapide et complètement silencieux (beau et compact). L’utiliser devient agréable et reposant, et je sens que je vais être plus productif/créatif avec

Voici quelques images sur le sujet.

Étant un véritable Geek fanatique de science, je m’intéresse bien sûr à l’Intelligence Artificielle. L’idée de programmer mon “animal de compagnie virtuel” me trotte dans la tête depuis un moment. Le plus simple étant de faire un “bot” qui essaye de répondre “intelligemment” à ce que je lui demande; avec une approche “déterministe”.

L’étape supérieur serait qu’il puisse me répondre avec une approche “euristique” à l’aide d’une éducation. Cette étape nécessite donc de maitriser les Réseaux de neurones.

Pour vulgariser le concept: on considère que le « cerveaux » est une boite noire, qui prend en entré des informations (un ordre exprimé dans l’interface de chat par exemple) et qui réalise, ou pas, quelque chose en sortie (ouvrir une application par exemple). Il faut donc éduquer longuement la boite noir pour lui dire quand est-ce qu’il faut qu’elle fasse cette chose et dans quel cas elle ne doit pas la faire.
Un peu comme un gamin qui se fait engueulé par sa mère et qui comprend quand est-ce qu’il peut jouer et quand il doit faire ses devoirs.

Cette étape peut s’avérer très longue, et on peut imaginer des solutions complexe pour accélérer le processus. On peut considérer que chaque réseau de neurones soient inter-connectés et agissent comme un réseau de niveau supérieur, un « méta-réseau » ou en somme un « cerveau virtuel ».

On peut alors y introduire les algorithmes génétiques: on considère que chaque cerveaux soient des individus distincts. Une action sera alors effectuer seulement si la majorité de la population prend cette décision.
Pour vulgariser le concept des algorithmes génétiques: le principe est de simuler la théorie de Darwin, c’est à dire que les individus les moins adapté aux règles de la vie, meurent, et on effectue des croisements génétiques entre les survivants pour obtenir des individus encore plus adaptés.
Ici seul les cerveaux qui prendrons la bonne décision (à savoir celle qui me plait le plus) survivront.
Cela permettra donc d’éduquer l’ensemble beaucoup plus vite puisque c’est comme si plusieurs individus réfléchissent de manière différente et qu’à un moment donnée on croise leur façon de penser pour en avoir une plus optimale.

On peut aussi appliquer l’algorithme génétique lors de simulations avant de donner une réponse définitive. Le cerveau virtuel pourra simuler plusieurs décisions de plusieurs réseaux, et voir laquelle est la meilleur (« meilleur » étant toujours celle qui me plait le plus).

La consécration de tout ça serai de ne plus avoir un « bot » virtuel, mais un robot qui grouille dans mon appartement. Certain me diront « va t’acheter un chat », mais c’est plus fun de le concevoir soit même

Mais on peut aller encore plus loin, à l’aide de la pensé collective. Pour l’instant, j’ai une population de cerveaux qui réfléchissent indépendamment les un des autres, et je réalise des croisements entre eux pour avoir un résultat optimal. Mais on peut imaginer qu’ils communiquent entre eux, qu’ils s’éduquent entre eux, et qu’ils n’attendent donc pas l’étape de croisement pour changer leur façon de penser. Une vrai société en somme!

Je m’emballe car tout ceci est bien sûr très complexe, mais les progrès dans ce domaine se font de plus en plus vite. J’avais envie de vous parler de tout ça après avoir vu cette vidéo qui montre des méduses robotiques qui communiquent par signaux lumineux et agissent comme un groupe.

Rien à voir avoir l’IA, mais ce que j’ai trouvai de plus fun dans ces vidéos c’est la méduse « flottante » dans les airs. Peut être que nos rues en seront infesté un jour?

Après 4 ans de développement, la communauté Mono est enfin parvenu à l’implémentation complète des Winforms : http://tirania.org/blog/archive/2008/May-13.html

On peux se demander “oui, mais pourquoi faire?” et je ne trouve pas de réponse à la question. En effet, il arrive souvent qu’une application .Net possède du Legacy et donc des dépendances COM ou P/Invoke. Dans ce cas, on ne peut pas la migrer (pour tester si une migration est possible: http://www.mono-project.com/Moma)

Mais comme je suis exigent en terme d’interface, je n’aime pas avoir une application “alien” qui ne ressemble pas à mon environnement Linux (GTK/QT). Certes, il est prévu d’avoir un meilleur support du moteur de thème lors du prochain GSoC, donc wait and see.

Rappelons que les Winforms sont une sur-couche .Net de l’API WIN32. Cette dernière n’existant pas sous Linux et MacOS, j’en profite alors pour féliciter les équipes de Mono pour leur implémentation “from scratch”.

D’un autre coté, l’implémentation WPF chez Mono avance plutôt vite. D’ailleurs, la première release de Moonlight vient de sortir. Il n’y a pas de dépendance WIN32 dans ce cas, et je vois plus l’avenir des applications .Net dans ce sens. Mais l’approche WPF est d’avoir un thème propre à l’application, comme c’est le cas pour les sites Web, on obtient la même interface sous Linux et Windows (et MacOS). Mais finalement je trouve que ces interfaces ne s’intègrent à aucun des 3 environnements.

J’avais déjà rédigé un billet sur la guerre entre les technologies de “présentation” dans le domaine du Web (Ajax/Flash/etc.). Je ne vous l’apprend pas, le monde “Desktop” et “Web” convergent. L’idée est plutôt simple: aujourd’hui on doit exécuter un OS qui héberge des applications “Desktop”, et on doit exécuter un navigateur pour les applications Web. On obtient une certaines confusion entre la barre des tâches pour les application et les onglets pour les sites Web. Tout ceci est beaucoup mieux expliqué sur ce blog.

Mais de plus en plus, le navigateur ne sert qu’à exécuter un plugin (Silverlight/Flash/Java) qui lui charge l’application.
L’objectif est de lancer une application Web comme une application “Dekstop”, en exécutant le dis plugin en standalone, ou de passer par un “mini navigateur” (qui ne sert que pour le rendu HTML+Ajax, sans navigation etc). C’est en tout cas ce que propose Adobe Air ou Mozilla Prism.

Il va donc être difficile de distinguer une application “Desktop” ou “Web”. Ceci me fait un peu penser aux Widgets du Dashboard sous MacOS (ou autre plagia).

Au même titre que le Web se rapproche du Bureau, les applications “lourdes” copient les techniques du Web question apparence. Il y a des tentatives d’utilisation de CSS en Swing/SWT, mais l’exemple le plus flagrant est la description de l’interface à l’aide de XML comme dans XAML.

On obtient ainsi des applications “Desktop” ne copiant pas du tout le style standard de l’OS, mais ayant son propre thème telle un site Web.

Le résultat peut s’avérer très jolie, très ergonomique, mais très “inconsistant” avec les autres applications. Pourquoi devrais-je apprendre une nouvelle interface? Pourquoi ne pas utilise un standard? Pourquoi ne pas me laisser choisir mon thème dans l’OS plutôt que de me l’imposer pour une application donnée?

Personnellement, je ne suis pas fan de toutes ces interfaces différentes, et je ne suis pas le seul.
Pour revenir sur l’OS Linux, un grand effort est fourni pour rendre les interfaces homogènes. On peut par exemple citer le projet Portland allant dans cette direction. Je peux alors apprécier ces efforts puisqu’il m’est devenu difficile de distinguer une application QT dans mon environnement GTK (essayez Skype sous Linux pour vous en convaincre).

Je voulais aussi citer Redhat comme, à mon humble avis, les pionniers en matières d’homogénéisation avec leur thème Bluecurve identique sous KDE est Gnome. D’autre projets ont suivis dans le même genre comme Tango.

Enfin, les interfaces graphiques sont en pleines évolutions ces derniers temps, avec l’exploitation des cartes graphiques récentes, offrant des “eye candy” très alléchants. Le monde GTK est en pleine réflexion pour les futures versions, et les thèmes supportent de plus en plus d’effet.
Je préfère de loin cette approche ou l’OS propose un système de thème avancé (avec des techniques proches du CSS) et l’applique à toutes les applications, rendant le tout homogène. Néanmoins, je distinguerai toujours les applications type “Widget” qui ressemblent plus à de “mini-site” ou “application Web” qui elle ont une apparence propre à elles.

Comment seront les interfaces des OS du futures? Va-t-on vers un gros bordel graphique, ou une homogénéisation? WPF va-t-il percer sous Linux? Quels vont être les applications Winforms qui vont être migré sous Linux?

Deux mondes s’affrontent: Java et .Net. Chacun choisi son camp, ou choisi les deux… moi j’ai la double nationalité Mais quand les deux mondes doivent alors communiquer? Je fais l’interprète. Voila le topo:
J’ai une application .Net qui a besoin de manipuler des classes Java, et pour se faire je passe par C++/CLI: comment avoir un pied dans du .Net et un autre dans du natif C++.

L’avantage de C++/CLI (Common Language Infrastructure) c’est qu’on peut mixer du code managé et non-managé. Je peux donc compiler un assembly .Net en C++, qui lui fait appelle à du pure code C++ natif. Ici en l’occurrence j’utilise "jni.h" pour communiquer avec la JVM à l’aide de jvm.dll.

Rentrons dans le vif du sujet: qu’est-ce que ça donne du coté de mon application C#:

// on démarre la JVM avec mes bons arguments
MathiasJniCpp.JVMWrapper.InitJvm(new String[] { "-Djava.class.path=Mathias.Jni.Java.jar" });

// on créer un objet .Net qui wrappe l'objet Java
// en C++/CLI, le destructeur des classes CLI sert de méthode "Dispose"
using (MathiasJniCpp.MyJavaWrapper javaObject = new MathiasJniCpp.MyJavaWrapper())
{
// faire mumuse avec...
javaObject.People = "Mathias";
Console.WriteLine(javaObject.SayHello());
}

// on libère la JVM
JVMWrapper.ReleaseJvm();

MathiasJniCpp c’est le namespace de mon assembly c++/cli, j’en reparlerai plus tard.
On voit que je manipule une classe JVMWrapper qui me permet de charger une JVM (et de la libérer). J’utilise aussi une classe .Net codé en C++/CLI. En fait, je l’utilise comme un classe C#, ou VB.net etc. C’est une classe “classique” .Net avec des méthodes et des propriétés.

Point intéressant à souligner: pourquoi utiliser using?
Pour rappelle, il y a des mots-clefs en C# très lié au Framework (comme foreach) et using en fait partie. Il prend les objets qui implémente IDisposable et fait appelle à la méthode Dispose() à la fin du bloque. Comme ça, je suis sûr de libérer la classe du coté JVM quand j’en ai plus besoin.

Je ne vais pas montrer tout le code, car trop long et disponible ici.
Mais voici un aperçu de la classe C++:

#include "jni.h"
public ref class MyJavaWrapper
{
private:
  static jmethodID initMethodId;
  static jclass clazz;
  jobject obj;
public:
  /* initialisation des métadata Java/JNI, à voir plus tard */
  static void initJavaMetadata()
  { ... }

  /* une méthode de notre classe Java que l'on wrappe, expliqué aussi plus tard */
  String^ SayHello(String^ people)
  { ... }

  /* constructeur */
  MyJavaWrapper(void)
  {
    // histoire de récupérer toutes les métadatas nécessaires du coté Java
    MyJavaWrapper::initJavaMetadata();

    // construction d'une instance avec le constructeur par défaut
    this->obj = JVMWrapper::env->NewObject(MyJavaWrapper::clazz, MyJavaWrapper::initMethodId);
  }

  /* "destructeur" */
  virtual ~MyJavaWrapper(void)
  {
    JVMWrapper::env->DeleteLocalRef(this->obj);
  }
};

ref class veut dire “c’est une classe .Net”. Mais… ma classe n’implémente pas IDisposable!! Et c’est quoi ce destructeur??
Et oui: le destructeur C++ pour un objet .Net est transformé en la méthode Dispose() et la classe devient alors forcement IDisposable. Pour gérer le finalize allez voir ici.

Je manipule le membre this->obj qui est tout simplement un “pointeur” sur notre objet java. En fait, c’est un jobject qui est un type définie dans "jni.h".
J’utilise la classe JVMWrapper qui me permet de communiquer avec la JVM, et je lui demande de créer un nouvel objet d’une certaine classe jclass avec un certain constructeur jmethodID et j’obtiens ainsi mon jobject.
Étant donnée que la classe et la méthode ne change pas, j’ai rendu ces données static.

Voyons maintenant ce que fait MyJavaWrapper::initJavaMetadata();:

/* initialise les metadata du coté Java */
static void initJavaMetadata()
{
  // si les métadata ne sont pas déjà récupérées...
  if(MyJavaWrapper::clazz == NULL)
  {
    MyJavaWrapper::clazz = JVMWrapper::env->FindClass("mathias/jni/java/MyJavaClass");
    MyJavaWrapper::initMethodId = JVMWrapper::env->GetMethodID(MyJavaWrapper::clazz, "<init>", "()V");
  }
}

C’est la dedans que j’obtiens une fois pour toute la représentation de la classe Java mathias.jni.java.MyJavaClass et la représentation de la méthode <init> avec en paramètre ()V.
Pour comprend le lien avec la classe, il n’y a pas trop de problème: c’est le fully qualified name avec des ‘/’ au lieu des ‘.’.
Mais en ce qui concerne la recherche d’une méthode, ça devient du charabia!!
En fait, <init> est une méthode un peu spéciale: c’est un constructeur.
Ensuite, on spécifie les arguments du constructeur que l’on cherche, et la on tombe sur une syntaxe barbare. Dans notre cas, on cherche le constructeur par défaut c’est à dire qui ne prend pas d’argument.
Mais pour mieux comprendre la syntaxe barbare, voyons d’autres exemples de méthodes:

JVMWrapper::env->GetMethodID(MyJavaWrapper::clazz, "setPeople", "(Ljava/lang/String;)V");

Traduction: je cherche la méthode setPeople qui prend un argument de type java.lang.String et qui retourne void.
Un autre exemple:

JVMWrapper::env->GetMethodID(MyJavaWrapper::clazz, "sayHello", "([Ljava/lang/String;Z;)I");

Traduction: je cherche la méthode sayHello qui prend un argument de type java.lang.String[] et un autre de type boolean et qui retourne un type int.

On retrouve cette syntaxe à beaucoup d'endroits, comme sous Eclipse par exemple. Pour plus d'explication voir la documentation officielle.

Si l'on veut maintenant appeler une méthode Java, on récupère sa représentation tout comme on le fait avec le constructeur, puis on l'invoque sur notre instance:

public ref class MyJavaWrapper
{
private:
  static jmethodID initMethodId;
  static jclass clazz;

  // notre représentation JNI de la méthode "sayHello"
  static jmethodID sayHelloMethodId;

  jobject obj;
public:
  /* initialisation des métadata Java/JNI */
  static void initJavaMetadata()
  {
    /* initialisation de la classe et du constructeur, comme vu précédemment
    [...]  */

    // on récupère la représentation de "sayHello"
    JVMWrapper::env->GetMethodID(MyJavaWrapper::clazz, "sayHello", "(Ljava/lang/String;)Ljava/lang/String");
  }

  /* sur l'appelle de cette méthode .Net, on fait appelle à la méthode Java */
  String^ SayHello(String^ people)
  {
    // j'utilise une classe spéciale pour convertir ma String^ .net en natif ou Java
    StringConverter peopleStringConverter(people);
    jstring jPeople = peopleStringConvert.toJava();

    // appelle de la méthode Java, j'ai le droit de caster en jstring car c'est un sous-type de jobject
    jstring jResult = (jstring)JVMWrapper::env->CallObjectMethod(this->obj, sayHelloMethodId, jPeople);

    // conversion du type Java en .Net
    StringConverter resultStringConvert(jResult);
    return resultStringConvert.toDotnet();
  }
};

Voila, maintenant vous savez:

• obtenir la représentation d’une classe Java
• obtenir la représentation d’une méthode d’une classe
• créer une instance d’une classe Java
• invoker des méthodes sur une instance

En conclusion:
l’API JNI c’est un peux comme utiliser la réflection. Ça a donc des conséquences en termes de performance. Pour information, créer 10000 objet en java prend 625ms, en pure .net ça donne 46ms et en .Net->JNI->Java ça donne 2.687s.
L’API JNI peut sembler barbare au début, mais on s’y fait et puis il y a la doc, alors RTFM ;).

C++/CLI c’est de la bombe en termes d’interop. C’est le pont parfait entre le monde .Net et le natif.
L’inconvénient c’est que la syntaxe C++ est lourde. Et elle l’est d’autant plus en C++/CLI car il faut y ajouter les spécificités .Net, et il faut aussi distinguer une instance managée et non-managée, et tout ça passe par de nouveau symboles/mots-clefs.
Les conversions de types entre les deux mondes ne sont pas faites implicitement, et il faut souvent jongler pour avoir le bon type. J’ai par exemple eu des problèmes lors des conversions de String avec JNI: il faut convertir la String^ .net en char* natif pour enfin construire une jstring. Les conversions ont été le plus pénible dans l’histoire.

Enfin, voici le projet complet: Mathias.Jni.CSharp.zip
Un petit rappel des liens utiles:

• http://dotnet.developpez.com/faq/cppcli/
• http://java.sun.com/j2se/1.4.2/docs/guide/jni/spec/jniTOC.html

Hier j’ai eu un petit coup de stress: je suis allé à tout hasard sur le site d’Apple et “oh joie” l’iMac a bénéficié d’une mise-à-jour… mais ce qui m’a le plus emballé c’est l’adoption d’un Nvidia 8800GS! Oui, ce n’est plus un ATI spécialisé dans le multimédia, mais bien une Geforce!

Certes, la version “GS” est très loin de la “GTX”… n’oublions pas qu’un iMac c’est comme un gros portable: compact, sans bruit et consommant peu. Sur ce dernier point j’ai lu des critiques qui souligne que l’Upgrade n’est pas sans conséquence sur la puissance consommée.

Pour vous dire toute la vérité, ça fait des années que je bave sur les Mac pour leur design, leur discrétion et leur OS. De plus, depuis les processeurs Intel et BootCamp, je rêve du triple-boot MacOSX-Windows-Linux:

• MacOSX: car c’est un superbe OS, et j’ai hâte de tester Cocoa
• Windows: car certains softs n’existent que sous Windows (certains jeux, Visual studio, etc.)
• Linux: car j’adore le libre, j’adore Linux et j’adore le libre (déjà dit?)

Je me suis souvent retenu d’en acheter un pour diverses raisons. La dernière étant “mais bordel, pourquoi ils n’ont pas mis une Geforce 8800???”. D’une part parce que leurs ATIs sont plus spécialisées multimédia que jeux, et je voulais me tester aux jeux “plus ou moins” récents en bootant sous Windows (car mon Athlon XP2000+ avec une GeForce6000GT commencent à faire vieux).
D’autre pars, car j’ai de mauvaises expériences avec ATI sous Linux (oui je l’avoue, c’est Compiz qui m’a fait acheter ma première NVidia… oui je suis trop geek…).

Mais maintenant je n’ai plus aucune excuse! Je me suis donc précipité à la Fnac hier dans l’après-midi.
Pas de chance: le nouvel iMac 3.06Ghz est trop récent, et ils ne l’auront que la semaine prochaine. Par contre, j’ai une infos qui peut vous intéresser: la Fnac propose d’échelonner ses paiements, et exceptionnellement au mois de Mai c’est sans frais (jusqu’à 15 mensualités).

Rendez-vous la semaine prochaine

J’ai eu une discutions intéressante ce midi au sujet du buzz en ce moment: Adobe open-source Flash! Je vois ça comme un premier pas vers la conquête du Web 3.0. Une guerre déjà entamé entre Adobe, Microsoft et le monde libre.

Haha, je sais que le terme Web 2.0 fait couler beaucoup d’encre (ou abîme les claviers) mais moi je le prend du point de vue du développeur:

Au début, il y avait le néant… puis l’informaticien inventa la page HTML! Dans sa foulé il inventa le Javascript… puis les applets Java… pas de chance, l’informaticien était en avance sur son temps…

Puis le Web s’est vu enrichir de nouveau média (Youtube, Deezer, etc.) Toute cette magie est possible grâce aux génies de Macromédia inventeurs du Flash! (racheté par la suite par Adobe)
Le web est devenu plus beau, plus fun… et plus lourd tout de même.
Flash est aujourd’hui la techno incontesté pour les médias riches. Elle était aussi en avance sur son temps: les sites entièrement Flash était encore trop lourd pour les débits de l’époque. Ce n’est aujourd’hui plus un problème, mais si tous les sites ne sont pas en Flash, je l’explique pour plusieurs raisons:
Premièrement, cette technologie était boudé par le monde Linux qui se retrouvé avec un produit propriétaire, des versions en retard par rapport à celles sur Windows, et même souvent bugguées.
Les adeptes des standards W3C ne voient pas non plus Flash d’un très bon œil et préfère se concentrer sur la norme HTML+ECMASCRIPT (autrement dit: Javascript).

C’est la que le Web 2.0 atteint son paroxysme: les sites Web d’aujourd’hui exploitent à fond le Javascript (Ajax, GWT, Scriptaculous, etc.). Cela donne des pages Web plus riches, plus interactives, plus animées, et plus légères!
Car oui, le bon vieux HTML avec un peu de Javascript c’est plus léger que du Flash. Certains dénonceront simplement les mauvais codeurs ActionScript qui sont souvent des graphistes reconvertis et qui font des choses non-optimisés…
Ceci dit, cette performance n’est possible que grâce aux effort fournis par les navigateurs Web qui supportent de mieux en mieux le Javascript.
Mais voila, les vidéos ou encore d’autres choses ne sont pas possibles en HTML+Javascript aujourd’hui, et c’est pourquoi que Flash est encore très utilisé (surtout concernant la vidéo).

C’est la que Microsoft riposte avec Silverlight et ça va faire mal.
Imaginez: un plugin similaire à Flash, mais plus performant (WPF utilisant gracieusement DirectX) avec des langages plus faciles à coder (C#, XAML, etc.) et des outils de développement/design très soignés (la série des Expression).

Mais la communauté pro-libre/pro-standard n’en reste pas la: HTML5 est censé combler les lacunes vis-à-vis de Flash ou Silverlight.

Sun veut aussi être de la partie, après l’échec des applets, il tente nous proposer JavaFX.
Les principales raisons de l’échec des applets sont:
- Java c’est gros et lourd à télécharger… imaginez un JRE de 30mo à l’époque des 56k!
- Ce n’est n’était pas non plus très performant, surtout en matière d’affichage.
- Il n’existe aucun outil pour graphiste pour faire des applets! C’est la que Macromédia avec Flash avait marqué un point.
- Ce n’est n’était pas libre… donc difficile à faire adopter par la communauté des développeurs.

Mais Sun propose des solutions:

• Java Kernel: le principe est simple, il faut que le téléchargement d’une JRE soit négligeable (tout comme Flash). Pour ce faire, l’utilisateur télécharge une version “minimale” de la JRE, qui téléchargera des paquets supplémentaires seulement s’il y en a besoin.
• Java2D/Swing plus performant, ainsi que l’accélération avec DirectX (elle existait depuis peux de temps, mais désactivé par défaut car trop buggué). Cela permet aussi des effets comme la transparence etc.
• JavaFX: ou comment créer un langage de description d’interface, pour créer plus simplement des animations etc.
• Java est open-source: à quand Java installé par défaut sous Linux? (Même si c’est maintenant un paquet officiel d’Ubuntu)

Le seul hick qui va faire très très mal: toujours pas d’outil puissant pour les graphistes.
On peut aussi se demander pourquoi avoir inventer un n-ième langage de script, là où tout le monde optent pour le XML comme descripteur d’interface.

On remarque que “Open-source” est maintenant synonyme de “standard”, et ça Adobe l’a compris. Fort se sa popularité, l’ouverture forcement va booster son engouement.
Microsoft n’est pas en reste dans ce domaine: depuis son alliance avec Novell, ils travaillent tous deux pour promouvoir .Net sous Linux même si l’équivalent à Silverlight en libre, Moonlight, est encore loin de voir le jour…
On pouvait pointer du doigt le manque de sérieux en matière de développement avec ActionScript, mais avec Flex ce n’est plus vrai.

Avec toutes ces technos, on se demande si le navigateur ne servira plus qu’a charger un plugin Flash/Java/Silverlight, et déléguera le travail de rendu à ceux la. Mozilla sonne l’alarme et explique l’importance de HTML5.

Les paries sont lancés:
Les prochains sites-web, en Flash? HTML5+Javascript? Silverlight/Moonlight? JavaFX?

Rien de plus stressant que de passer une journée entière sur un bug. Surtout si on n’a aucune idée du problème (pas d’exceptions, ni d’erreurs dans les logs) et que les recherches sur Internet sont infructueuses.
Contexte : une application Web Asp.Net communique avec un service WCF.
Problème : au bout d’un certain nombre d’appels (invariant) l’application Web n’arrive plus à joindre le serveur (Timeout).

Pour conserver une trace de mon incompétence, voici donc la solution:
Pour qu’on puisse dialoguer avec un service WCF dans une page Asp.net, je leur injecte un proxy à l’aide de Spring (voir Spring.net pour le web). Pour cela, j’utilise une “factory de proxy” à l’aide de l’interface IFactoryObject.
Crédule que j’étais, j’imaginais que le fait de retourner true pour la propriété IsSingleton allait faire en sorte que Spring.net ne fasse appel qu’une seule fois à la méthode GetObject().
Et bien non ! C’est à vous d’être cohérent: même si IsSingleton retourne true, rien ne vous empêche de toujours retourner une instance différente dans la méthode GetObject().

Pour en revenir à mon problème, vous l’aurez compris : ma méthode GetObject() retournait à chaque fois un nouveau proxy vers le service WCF.
Résulat : à chaque fois que Spring avait besoin d’injecter mon proxy à une page (postback par exemple), je créai une nouvelle connexion au serveur WCF. J’ai fini par atteindre le nombre de connexion max, et le serveur ne répondait plus.

Il est tout de même dommage que les traces WCF ne m’ont pas révélé d’exception expliquant cette limite max de connexion

Pour approfondir le sujet sur les IFactoryObject :
Un objet qui implémente IFactoryObject doit toujours être un singleton, si ce n’est pas le cas on obtient une exception:

<object id="maFactory" type="MonAssembly.MaFactory, MonAssembly" singleton="false"/>


=> IFactoryObject must be defined as a singleton - IFactoryObjects themselves are not allowed to be prototypes.


La propriété IsSingleton de la factory indique seulement ce qu’elle est censée faire… mais sans aucune obligation/vérification du comportement. Dans mon cas, je retournais true mais rien ne m’a empêché de créer une nouvelle instance à chaque appel…

Dans le cas particulier d’une application Asp.net, on peut avoir des “presque singleton” en changeant le scope:

<object id="maFactory" type="MonAssembly.MaFactory, MonAssembly" scope="application"/>

• scope=”application” : c’est un singleton de toute l’application web. Firefox et Safari m’affiche toujours 1.
• scope=”session” : c’est un singleton pour chaque session cliente. Firefox et Safari m’affiche toujours 2 (1 instance pour Firefox + 1 instance pour Safari).
• scope=”request” : c’est un singleton dans le cadre de la requête. Firefox et Safari vois le compteur s’incrémenter à chaque rafraichissement de la page.

Pour plus d’infos sur les scopes.

Conclusion(s) :

1. Ce n’est pas la propriété IsSingleton qui détermine si Spring va faire appelle une ou plusieurs fois à votre Factory. C’est à elle de fournir le comportement adéquat.
2. Un singleton n’en est pas toujours un… ça dépend du contexte. Dans tous les cas, pour éviter les erreurs comme la mienne, n’oublier pas d’utiliser la destroyMethod pour libérer les ressources. (l’interface ILifeCycle de Java n’existe pas encore dans Spring.net mais la 1.2 sort en RC1 début mai…).
3. Un “Timeout” peut vouloir dire “trop de connexion au serveur”
4. Cette fameuse Factory de proxy WCF sera fournie dans Spring.net 1.2. j’aurais perdu moins de temps en prenant les sources des nightbuilds… vive l’OpenSource!

On a parfois besoin de livrer une application .Net avec les fichiers de ressources, afin qu’un traducteur, voir même un intégrateur, puisse faire les traductions au dernier moment.

Si cette personne doit recompiler l’application pour voir le fruit de son travail, ce n’est pas très pratique voir impossible: allez lui expliquer que VisualStudio n’est pas nécessaire et qu’il est possible de créer des ressources avec ResGen.exe (et al.exe pour faire des assembly satellites). Très franchement, les traducteurs ne veulent pas de quelque chose d’aussi et vont vous fuir comme la peste si vous leur demander d’être des développeurs.

La solution est donc d’utiliser simplement des fichier *.resx sans les compiler, et elle a plusieurs avantages:

• le traducteur n’a pas à savoir comment compiler des ressources (ce n’est pas un développeur)
• les fichiers *.resx sont sous la forme XML, et donc (très?) lisible (la structure propose même un champ “commentaire”)
• il existe bien sûr des éditeurs de fichiers *.resx pour ceux qui ne veulent même pas savoir ce que XML veut dire: Resourcer for .net

Vous pouvez retrouver ces explication sur le blog suivant.
Et Oh joie! Ce blog explique comment réaliser un ResourceManager personnalisé capable de charger des fichiers .resx! C’est donc tous ce qu’il nous faut, nul besoin de réinventer un autre mécanisme de traduction maison.

Pour pousser la réflexion plus loin, je voulais utiliser Spring.net pour obtenir la traduction. Cette solution à pour avantage de ne passer que par le contexte pour obtenir cette dernière, peut importe dans quel fichier elle se trouve. Il suffit alors de paramétrer dans le fichier App.Config le chemin de chaque fichier *.resx.

Pour ce faire, rien de plus facile: Spring.net fournit une classe qui recense un certain nombre de ResourceManager. En référençant donc notre ResxResourceManager qui pointe sur notre fichier *.resx, le contexte Spring sera alors capable de fournir les bonnes traductions si on l’interroge. Pour obtenir une traduction dans la culture courante, il suffira alors d’écrire ceci:

ContextRegistry.GetContext().GetMessage("MaClef");

Le XML de configuration ressemble à ça:

<object name="messageSource" type="Spring.Context.Support.ResourceSetMessageSource, Spring.Core">
  <property name="ResourceManagers">
    <list>
      <!-- ResourceManager qui pointe sur notre fichier Resx\MyResource.resx -->
      <object id="MyResource" type="TestWinformsRessources.ResxResourceManager">
        <constructor-arg name="baseName" value="MyResource"/>
        <constructor-arg name="resourceDir" value="Resx"/>
      </object>
    </list>
  </property>
</object>

Vous pouvez voire concrètement ce que ça donne avec un petit exemple.