mercredi 21 août 2013

Acheter ou louer son logement ? Voici un simulateur en AngularJS !


Je me pose cette question comme beaucoup de français qui ne sont pas encore propriétaires.

Il faut dire qu'il est assez difficile de répondre sérieusement à cette question.

Comme je trouve AngularJS plutôt intéressant, je me suis dit  qu'il serait utile de construire un simulateur avec cette technologie pour enrichir mes connaissances sur le sujet.

Voici donc le simulateur : http://www.acheteroulouer.eu/

Techniquement, j'ai utilisé le framework CSS de Zurb ce qui m'a permis de voir autre chose que Bootstrap.

Le cache applicatif HTML 5 est utilisé pour la plupart des ressources.

Le stockage local est lui utilisé pour mémoriser les paramètres de la simulation.

Au final, mis à part lors du premier chargement, le simulateur travaille côté client, ce qui permet d'économiser sur les ressources de production.

Enfin, le fonctionnel est également très intéressant : cela été l'occasion de voir les principaux postes de dépenses pour une ou l'autre option.

Ce simulateur prend en compte les dépenses énergétiques ce qui est rarement le cas sur les autres simulateurs alors même que les normes thermiques en vigueur permettent déjà des économies très substantielles.

A vos simulations !

vendredi 12 juillet 2013

Java : Why you should not use getClass().getClassLoader()


ClassLoader is a useful class when dealing with dynamic resource loading.

Common use is to load at runtime some configuration files or others kind of ressource : .properties, .xml, .png, ....

It gives you a convenient access to the classpath of your application.

The classpath ? Is there only one classpath ?

Not so fast !

Classloading


Classloading is one of the most unknown aspect of Java features but it's one of the most important and most magic feature.

Indeed this process is able  to load your code dynamically even if this code is somewhere on the network.

Classloading stands on ClassLoader and there are lot of things done behind the curtain when you start a Java program.

Run a Java application, anything you want, but just add the  -verbose:class option to the Java command line.


Here is a sample output :


[Opened /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Object from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.io.Serializable from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Comparable from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.CharSequence from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.String from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.reflect.GenericDeclaration from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.reflect.Type from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.reflect.AnnotatedElement from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Class from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Cloneable from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.ClassLoader from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.System from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Throwable from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Error from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.ThreadDeath from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Exception from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.RuntimeException from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.security.ProtectionDomain from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.security.AccessControlContext from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.ReflectiveOperationException from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.ClassNotFoundException from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.LinkageError from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.NoClassDefFoundError from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.ClassCastException from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.ArrayStoreException from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.VirtualMachineError from /Library/Java/JavaVirtualMachines/jdk1.7.0_10.jdk/Contents/Home/jre/lib/rt.jar]
...


ClassLoader


It's very important to understand there are many ClassLoader used in a Java Application.

Each ClassLoader is responsible for loading a piece of the overall class path.

At runtime, ClassLoader are linked to each other : this is known as the class loader hierarchy.

Application server use their own hierarchy which can be quite complex.

The key point is : the class loader responsible for loading a class will associated to this class for life, even if this class object is used in a context with another class loader.


getClass().getClassLoader() returns always the same ClassLoader object.


Here is a sample code.

As you can see the parent class loader of my main class can not find a resource which is in my application class path.


Thread context


Each thread has a context class loader.

When  you need to get some resource use the context thread class loader because it has access to the most complete class path.

Indeed, if you use the class loader of any class object, you'll get the class loader which loads this class the very first time.

This class loader may access to your resource but you can not know for sure.

So : Thread.currentThread().getContextClassLoader() is the key !





  










lundi 8 juillet 2013

JQuery perfomance tip : visible and hidden selector



As client side components becomes smarter, Javascript performance becomes a real concern which can turn user experience to a dream or a nightmare.

JQuery is a mandatory tool you need for some use cases .

One of this use case is  about stripping table rows with even and odd colors.

You can do it using CSS 3 selector :

tr:nth-child(even) {background: #CCC}
tr:nth-child(odd) {background: #FFF} 

But sometimes you need to deal with more complex tables.

Imagine you have a table of data : some TRs are not data directly but some extra informations about data, let's say a detail view of data you want to hide and show when user click on some place on the data row.

So you will  get an HTML stream like this :


<tr data-isdata="true">
     <td>drtykRnZWhIFYkbTwuNkrBuZvBtJEwVDvLFC</td>
     <td>GGRpOQXnEUIUrLztepXPgkNQukEHOKNYoXmO</td>
     <td>fQzhJfjzVmkxGxQAKYVLbdjsLriosPWcNNhq</td>
     <td>pCeIsdthjvnfPtEVfuswGPZpCMbAneejMPbf</td>
     <td>iMzqEzOpecwHwNkoewhynidzUliwMhGEidOe</td>
     <td>XWteGfqPeAXHiNEGxTurkWuMagYeGXosiGdX</td>
</tr>
<tr style="display:none;">
     <td col="7">Some extra informations to hide or show.</td>
</tr>


Now, you are stucked with CSS 3 selectors because you can not select  odd or even nodes with metadata isdata :

tr[data-isdata]:nth-child(even) {background: #CCC}


Does not work since nth-child apply to the element tr and not to the whole tr[data-isdata].

You can actually check this with new HTML 5 API for querying the DOM :

document.querySelectorAll("tr[data-isdata^='true']:nth-child(odd)")

This returns all the nodes carrying data-isdata attribute and not the odd ones.

Plus, you need to strip only visible rows !

CSS 3 don't provide a convenient way to select the nodes we need here.

Visible


Now, you need JQuery : it's very easy to select the nodes we need but you can do it using different ways.

One of the obvious way is to use visible selector :

$("tbody > tr:visible:odd").addClass("odd");
$("tbody > tr:visible:even").addClass("even");

Quite easy isn't it ?

Yes, but quite slow too !

In certain cases, this selector can literally crush the browser, i've seen the browser for 30 seconds with some complex tables with 500 rows !

The visible selector is slow because it does not exist in CSS, it's computed using many other properties :


return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 ||
                        (!jQuery.support.reliableHiddenOffsets && ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none");


This piece of code is the core of hidden method called by the visible one. The visible method apply a not operator after calling hidden method.

Metadata


The use of a dedicated metadata for visibility is much more faster than the visible or hidden selectors.


<tr data-isdata="true" data-isvisible="true">
     <td>drtykRnZWhIFYkbTwuNkrBuZvBtJEwVDvLFC</td>
     <td>GGRpOQXnEUIUrLztepXPgkNQukEHOKNYoXmO</td>
     <td>fQzhJfjzVmkxGxQAKYVLbdjsLriosPWcNNhq</td>
     <td>pCeIsdthjvnfPtEVfuswGPZpCMbAneejMPbf</td>
     <td>iMzqEzOpecwHwNkoewhynidzUliwMhGEidOe</td>
     <td>XWteGfqPeAXHiNEGxTurkWuMagYeGXosiGdX</td>
</tr>
<tr style="display:none;">
     <td col="7">Some extra informations to hide or show.</td>
</tr>

I've built a sample sample with the two ways : the metadata way is 4 times faster than the visible way.

Check the sample on Gist.

Here are the selectors :

var tbody = $("tbody");
tbody.find("tr[data-visible]:odd").addClass("odd");
tbody.find("tr[data-visible]:even").addClass("even");

With a profiler (use Google Chrome "Profile" for instance) you can see that the method strip2 based on metadata selector is many times faster than the visible one.

The main pitfall of the metadata approach is to put extra load on server side and network bandwidth, the metadata is a piece of data you have to generate and carry through the network.

As usual performance tuning is a matter of balance !







mercredi 3 juillet 2013

Mod_JK : session mixed between users



I worked a few weeks ago on a particularly vicious bug.

Some users of our JEE web applications experimented a change of identity when they were working quietly.

Better, they were in the session of another user, set in a context that was not theirs.

Our architecture is based on Apache, Mod_JK and Glassfish.

A track


After googling a few minutes I found a serious lead: a critical bug in Mod_JK still open, entitled Response mixed betweens users.

The bug is opened in 1.2.28 as 1.2.19 but we must never forget that the discovery of a bug in a version that does not mean the bug did not exist before.

Even if the form does not mention the bug Glassfish, I assume this is a Mod_JK  bug.

So I decided to set up a test environment to try to reproduce the bug at will.

For this, some system commands later, I find myself with a proper environment.

Session mixing: how is this possible?

How to verify that occurs ?

If the bug is rare  then there is little chance that manual testing can reproduce the problem.

We must first understand how it happens : when a user receives the response to a query it was not intended to !

Indeed, the response header Set-Cookie is returned for each response sent by the Glassfish server. Note that Tomcat does not work the same way by issuing the response header Set-Cookie only once, when creating the session.

Glassfish and is more vulnerable to this Mod_JK  bug as all responses from the server contain this header field when the JVM is configured with a JVM route.

If Mod_JK mixes responses then users will receive a session cookie that is not for them.

How to check this?

After reading the comments on the bug, I've realized that this bug was kind of stealth or very stealthy.

The probability to reproduce this bug by hand,  playing with multiple browsers is almost zero.

JMeter to the rescue


JMeter is in my opinion a first-rate tool, both simple and powerful for those who know to exploit it (it's quite convenient for small load because of its thread based model).

It will allow me to generate a significant number of user sessions on a single JEE web and check for each query if the associated response contains the same Set-Cookie header.

We need a BeanShell assertion to check the crucial point: is there sharing session?

Here is the script (this is not a Groovy file but a BSH one, Gist does not know BSH).

You can find the JMeter script and BSH script here in my github repo.

This script should be used for each query in a BeanShell assertion with JMeter 2.9.

You can either reference a file that contains the code or paste the code in the box provided in the statement.

With this script I could reproduce the problem : check JMeter log file to see the mixing.

The rate is about 0.8 mixing for 1000 requests.

This is low, but for a web application that knows a sustained traffic, it is enough to be a major security risk.

Is this really a bug Mod_JK ?

Using Mod_proxy removed the behavior.

This does not come from the application. This observation is consistent with some evidence related to the bug.

Lessons


This expertise has been a confirmation of felt about the evolution of our architecture for me.

Several people were mobilized for a month to try to isolate and reproduce the problem, without success.

Architectures are more and more complex: it is almost impossible to solve problems without method or extreme rigor.

However, some professionals continue to understand the technical issues such as "before" no methodology is well established, no reliable configuration management of the architecture components, no trace when trying to copy, modify several parameters of architecture without properly control the scope of these changes, ...

A few days ago Michael Shallop published an article on the 5 best rules for debugging and diagnostic.

I recommend this article.




Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.

HTML 5 Offline : IndexedDB Cleaner



I've built a small but useful Chrome extension to purge IndexedDB.


So, here it is : IndexedDB Cleaner

This extension can be used in combination with Local Storage Cleaner and Appcache Cleaner, found on same page.

Enjoy !






Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.

lundi 24 juin 2013

Mod_JK : mélange de session utilisateur


J'ai travaillé il y a quelques semaines sur un bug particulièrement vicieux.

Certains utilisateurs de nos applications webs JEE expérimentaient un changement d'identité alors qu'ils étaient en train de travailler tranquillement.

Mieux ils se retrouvaient dans la session d'un autre utilisateur, positionné dans un contexte qui n'étaient pas le leur.

Notre architecture est basée sur Apache, Mod_JK et Glassfish.

Une piste


Après avoir googlé quelques minutes je suis tombé sur une piste sérieuse : un bug critique sur Mod_JK  toujours ouvert, intitulé Reponse mixed between users.

Le bug est ouvert en 1.2.28 alors que nous sommes en 1.2.19 mais il ne faut jamais oublier que la découverte d'un bug dans une version ne signifie pas que le bug n'existait pas avant.

Même si la fiche du bug ne mentionne pas Glassfish, je table sur le fait qu'il s'agit d'un bug Mod_JK.

Alors je décide de monter un environnement de test pour tenter de reproduire à volonté le bug.

Pour cela, quelques commandes systèmes et quelques coups de vi plus tard, je me retrouve avec un environnement prêt à l'emploi.


Echange de session: comment est-ce possible ?


Comment vérifier que des échanges de session se produisent ?

Si le bug est rare ce que laisse à penser les remontées des utilisateurs alors il y a peu de chance que des tests manuels permettent de reproduire le problème.

Il faut d'abord comprendre comment un échange de session se fait.

Pour cela il suffit qu'un utilisateur reçoive la réponse à une requête qui ne lui était pas destinée.

En effet, l'entête de réponse Set-Cookie est renvoyé pour chaque réponse émise par le serveur Glassfish. Il faut remarquer que Tomcat ne fonctionne pas de la même manière en émettant l'entête de réponse Set-Cookie que lors de la première réponse qui suit la création de la session.

Ainsi Glassfish est plus vulnérable à ce bug Mod_JK car toutes les réponses provenant de ce serveur contiennent cet entête quand le domaine est configuré avec une route JVM.

Si Mod_JK mélange les réponses alors les utilisateurs vont recevoir un cookie de session qui ne leur est pas destiné.

Comment vérifier cela ?

A la lecture des commentaires sur le bug, je me suis rendu compte que ce bug était du genre furtif voire très furtif.

La probabilité de reproduire à la main ce bug en jouant avec plusieurs navigateurs est quasiment nulle.

JMeter à la rescousse


JMeter est à mon sens un outil de premier ordre, à la fois simple et puissant pour celui qui sait l'exploiter.

Il va me permettre de générer un nombre conséquent de session utilisateur sur une application web JEE simple et de vérifier pour chaque requête si la réponse associée contient bien le même cookie de session.

Ensuite, il suffit d'un script BeanShell dans une assertion JMeter (testé avec la 2.9) pour vérifier le point crucial : y a t-il échange de session ?

Voici le script :


Loading ....

Ce script doit être utilisé pour chaque requête dans une assertion BeanShell.

Vous pouvez soit référencer un fichier qui contient ce code, soit coller le code dans la zone prévue dans l'assertion.

Grâce à ce script j'ai pu reproduire le problème. La fréquence s'établit à 0.8 échange de session pour 1000 requêtes.

Ceci est faible mais pour une application web qui connait un traffic soutenu sur une journée de travail, c'est suffisant pour constituer un risque majeur de sécurité.

Est-ce vraiment un bug Mod_JK ?


L'utilisation de mod_proxy a supprimé ce bug.

Cela ne venait donc pas de l'application. Cette observation est conforme à certains témoignages associés au bug.

Les enseignements

Cet expertise a été pour moi une confirmation d'un ressenti quant à l'évolution de nos architectures.

Plusieurs personnes avaient été mobilisées pendant un mois pour tenter d'isoler et reproduire le problème, sans succés.

Les architectures sont de plus en plus complexes :  il est devient quasi impossible de résoudre certains incidents sans méthode et sans une rigueur extrême.

Or certains professionnels continuent d'appréhender les problèmes techniques comme "avant" : pas de méthodologie bien établie, pas de gestion de configuration fiable sur les composants de l'architecture, pas de traçabilité lors des tentatives de reproduction, modification de plusieurs paramètres de l'architecture sans bien maîtriser la portée de ces changements, ...

Il y a quelques jours Michael Shallop a publié un article sur les 5 meilleures règles de débogage et de diagnostic à connaître.

Je vous conseille la lecture de cet article.





Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.

mercredi 19 juin 2013

JSF and AJAX : un mariage heureux si vous comprenez la gestion des IDs



JSF 2 apporte un support  de haut niveau pour vos cas d'usages AJAX : il faut cependant comprendre la gestion des IDs pour bien en profiter.

Les IDs


IDs, comme leur nom le laisse supposer, permettent d'identifier les composants dans la vue.

Chaque composant est à une place précise dans la vue, l'ensemble forme un arbre de composants.

Chaque ID doit être unique.

Lorsque vous utilisez la balise ajax de JSF vous utilisez des IDs pour l'attribut execute et l'attribut render.

Cas d'utilisation


Voici un exemple simple :

Loading ....



Je veux rafraîchir  3 zones lorsque ma requête AJAX est terminée :

- output à l'intérieur du formulaire principal
- output2
- output3 à l'intérieur du second formulaire


Comme un système de fichier UNIX



Tout est dans l'utilisation du caractère ":".

Qu'est ce que veut dire ":" ?

Il faut considérer ce caractère comme  le slash d'UNIX.

Les composants sont comme des fichiers, certains sont des répertoires : ils contiennent d'autres composants.

Certains répertoires sont spéciaux, ils ont une influence sur la manière dont les IDs client sont calculés.

Ces composants spéciaux sont des  naming container, ils donnent leurs IDs à leurs enfants comme un préfixe.

Si vous étudiez le XHTML vous verrez que  mainform or secondform sont des préfixes de certains IDs de composants fils.

Quand une requête AJAX est en cours alors le contexte courant pour le calcul des ID est le  naming container le plus proche dans la hiérarchie.

Tous les IDs utilisés dans la balise ajax sans ":" sont évalués depuis ce point de départ.
C'est en quelque sorte le dossier courant.

La solution


Dans l'exemple ci-dessous, ma balise AJAX doit utiliser les IDs suivants :


Loading ....

Pourquoi ?


1) Quel est le naming container le plus proche ?

C'est mainform.

2) Quelle est la relation entre output et mainform ?

output est un fils, je peux le cibler directement car je suis dans le répertoire mainform:

./output -> output

3) Quelle est la relation entre output2 et mainform ?

Il n'est pas dans mainform, je dois passer par la racine de l'arbre, comme je le ferais avec un système de fichier :

/output2 -> :output2

4) Quelle est la relation entre output3 et mainform ?

Il n'est pas dans mainform, je dois passer par la racine de l'arbre mais il est dans le "dossier" secondform :

 /secondform/output3 -> :secondform:output3

Quelques balises sont des  naming container :
- data
- form

Attention,  tous les composites sont des naming containers !

Ils ont un impact sérieux sur la manière dont vous devrez spécifier les IDs dans les balises AJAX.
Dans le doute, n'hésitez pas à inspecter le XHTML pour vérifier les clients IDs.

A vous de jouer !





Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.

mardi 18 juin 2013

TOGAF : une philosophie pour l'architecte



Une méthode de plus ?
Une usine à gaz pour fabriquer des tours d'ivoire pour les architectes ?

Après une semaine de formation à TOGAF 9 et une certification niveau 2 réussie, je dois dire que cela reste une des expériences les plus importantes de ma carrière.

Je vais tenter d'expliquer pourquoi.

TOGAF kesako ?


TOGAF a été créé dans les années 90 par des professionnels de terrain, de vrais gens qui travaillent dans les départements informatiques de grosses entreprises ou qui conseillent ces dernières.

Ces gens se sont mis à échanger sur leurs pratiques de l'architecture d'entreprise et ont tenté d'élaborer un socle commun de pratique pour produire de l'architecture.

Ces échanges se sont faits sur les forums de l'OpenGroup et ont abouti à la naissance de TOGAF, qui veut dire : The Open Group Architecture Framework.  

TOGAF est donc un cadre d'architecture pour la transformation des systèmes d'information : l'idée est donc d'installer une nouvelle gouvernance par l'architecture.

Le premier point important est de comprendre que TOGAF est fait par des gens de terrain et non par des gens "hors sols" qui n'ont jamais travaillé dans ou pour une entreprise. 

TOGAF est tout sauf un modèle théorique, il est construit sur la base de pratiques qui lui pré-existent et qui fonctionnent sur le terrain, raison pour laquelle elles se trouvent dans le cadre.

Nous allons voir quelques concepts TOGAF de base pour vous donner envie d'aborder cette méthode.


Architecture, de quoi parle-t-on ?


TOGAF définit l'architecture comme une activité de management qui vise à transformer l'entreprise de manière rationnelle. Pour cela il faut faire des plans du présent et du futur. 

L'analyse de l'écart permet de connaître et donc maîtriser les travaux futurs.

Comme dans le bâtiment, de nombreux corps de métier sont impliqués pour représenter tous les aspects  de la transformation.

Une fois que les plans sont faits et validés par les donneurs d'ordre alors les travaux réels commencent.


TOGAF une méthode de plus ?


TOGAF contrairement à d'autres méthodes est pragmatique. 

A ce titre, ce cadre implique que les praticiens soient suffisamment matures pour l'adapter à leur entreprise.

Parmi les premières étapes de la mise en oeuvre d'une démarche TOGAF, il existe une étape particulièrement importante : la mise en place du cadre de capacité d'architecture d'entreprise.

Cette étape m'a ouvert les yeux sur un certain nombre de points cruciaux pour notre métier d'architecte.

D'abord, la construction de cette capacité permet d'interroger profondément sa pratique de l'architecture.

En effet, le cadre de capacité d'architecture vise à définir les moyens et les buts de l'architecture pour chaque entreprise en fonction de ses moyens.

Premier élément, chaque entreprise est différente de par sa culture, ses moyens et ses transformations. Il y a donc autant de pratique d'architecture valable que d'entreprise.

Selon TOGAF,  il faut créer son TOGAF, donc sa propre méthode.

Nous architecte, avons trop tendance à demander ou à présenter des travaux d'architecture selon notre goût , la mode du moment ou les canons esthétiques posés par une référence culturelle reconnue (tel gourou mondial) ou moins reconnue (j'ai toujours fait comme ça, dans la boîte de service on nous dit de faire comme ça, ...).

Oui très bien, mais quel est la valeur de ce travail pour l'entreprise ? 

TOGAF donne une sérieuse leçon de pragmatisme et d'humilité : un travail d'architecture produit ou commandé dont ne peut estimer ou prouver la valeur pour l'entreprise n'a aucune valeur.

Il est même dangereux parce qu'à terme l'accumulation de ce genre de travaux a tendance à se transformer en un bâtiment de forme ronde, de haute taille et  de couleur ivoire, avec des gens en colère qui tourne autour prêt à en découdre.

Je vous laisse devenir qui est dans la tour.

Premier enseignement, un travail d'architecture est correct non pas quand l'architecte est content mais quand il est conforme au cadre de capacité d'architecture lui même conforme aux aspirations et contraintes de l'entreprise.

L'architecture n'est donc pas au service de l'architecte mais de l'Entreprise. 

C'est évident me dirait vous ! Pas tant que cela, réfléchissez-y toutes les solutions que vous mettez en oeuvre ont-elles une valeur pour l'Entreprise ? Etes-vous en mesure de démontrer clairement cette valeur ?

Les plus attentifs d'entre vous auront remarqué que j'ai utilisé un E majuscule pour entreprise.

Ce n'est pas pour faire l'intéressant, vous allez voir.


Alors l'Entreprise c'est quoi ?


Chaque interlocuteur qui lira les paragraphes précédents se dira que le mot Entreprise est une autre façon de désigner ses préoccupations. Pas tout à fait ...

TOGAF définit l'Entreprise comme l'ensemble des acteurs concernés par une transformation.

Par acteur concerné, TOGAF entend tous les acteurs concernés qu'il soit hors de l'entreprise au sens juridique (les sous traitants par exemple, le grand public, ...) ou dans l'entreprise (les salariés de l'entreprise).

Si l'on considère par exemple un transformation d'un système d'information, il faut considérer aussi bien les acteurs fonctionnels que techniques, les fournisseurs qui vont participer à la transformation, ....

Il est également important de considérer le concept de transformation comme un changement dans l'architecture de l'Entreprise : un changement peut être une augmentation des capacités de l'Entreprise  (achat d'un concurrent, migration vers une technologie plus performante, ...) ou la suppression d'une capacité (arrêt d'un produit, vente d'une partie de l'Entreprise, ...).

L'intérêt donc de l'Entreprise est donc l'ensemble des intérêts des acteurs concernés.

De facto, TOGAF est une méthode qui prend en compte dès le départ dans ses fondements même, que l'architecture est l'art de construire un compromis. L'intérêt des fournisseurs n'est pas le même que celui du client qui lui même se compose de groupes aux préoccupations diverses.

Vous aurez probablement remarqué que cet art du compromis n'est pas forcément répandu dans nos entreprises, les situations conflictuelles entre les fonctionnels, les achats et les techniques sont légions et parfois apparaissent bien tard.

TOGAF insiste aussi sur le fait qu'une transformation n'est pas toujours positive, il faut prendre en compte aussi bien les acteurs qui ont a perdre que ceux qui ont a gagné à la transformation. En effet, il ne faut pas oublier qu'un acteur touché négativement peut très bien avoir une influence importante ce qui peut être une cause d'échec ou de perturbations sévères.

Points de vue


TOGAF notamment dans l'étape de mise en place du cadre de capacité indique qu'il faut déterminer pour chaque acteur concerné, le juste point de vue.

En effet, le point de vue des achats n'est pas celui de la production qui n'est pas celui du métier.

Il est inutile et dangereux de tenter de communiquer avec les acteurs concernés sans structurer les informations avec le point de vue adapté. C'est une source de frustation et d'incompréhension pour les acteurs.

Vous n'obtiendrez pas un compromis satisfaisant en utilisant les même représentations pour tous les acteurs concernés.

L'idée est qu'une architecture de SI est comme une architecture réelle : l'architecture d'un bâtiment est composée de multiples point de vue légitimes (plomberie, électricité, équipements de sécurité, ...),  chaque corps de métier possède son langage et ses représentations.

L'architecte a la vision globale et doit résoudre les conflits et les incohérences entre les différents points de vue.

Le cadre de capacité


Ce cadre est fondamental, c'est lui qui permet de construire votre capacité d'architecture qui se traduira par une nouvelle gouvernance : commissions, dossier d'architecture, revues diverses, ...

Tout vient du cadre de capacité.

Ce cadre est une méthode dans la méthode, il vous guide dans la mise en place de tous les outils nécessaire pour produire de l'architecture.

Il fournit des profils types, des grilles de compétences, des modèles d'organisation, ....

Comme TOGAF est basé sur des retours d'expérience, il propose des outils qui fonctionnent et surtout conduit l'équipe qui va utiliser le cadre de capacité à se poser des questions fondamentales pour construire la capacité de l'Entreprise :

L'Entreprise a-t-elle moyen de supporter cette gouvernance ?
Combien ça coûte ?
Quels sont les ressources humaines nécessaires ?
Quelles sont les acteurs concernés ?
Quels sont les points de vue utiles à ces acteurs ?
Quelles sont les personnes physiques impliquées avec quels rôles ?
Etc ...

Il est illusoire de créer soit même une capacité d'architecture sans tenir compte de ces bonnes pratiques car il s'agit d'une démarche complexe.

Une capacité d'architecture qui fonctionne implique que de nombreux acteurs de l'Entreprise y compris des acteurs non techniques y participent.

Tous ces acteurs sont par ailleurs impliqués dans leur métier au quotidien et "ont d'autres chats à fouetter". La mise en place d'une telle gouvernance leur apportera de nouvelles contraintes et une charge de travail accrue.

Pour éviter de décrédibiliser totalement cette démarche il est important d'éviter tout amateurisme et empirisme car l'architecture est l'affaire de tous et non de quelques architectes.

Si les conditions optimales ne sont pas réunies vaut mieux revoir ses ambitions à la baisse que de monter une gouvernance qui ne sera pas opérationnelle pour tout un tas de raison, quitte à monter en puissance au fil du temps.

Conclusion

A travers quelques exemples de concept TOGAF, j'espère vous avoir donné envie de vous plonger dans cette méthode.

Pour ma part, une des intérêts de TOGAF réside dans l'approche globale de l'architecture des SIs, elle offre des outils conceptuels très puissants pour appréhender la complexité des travaux de transformation des SIs.

Enfin, même si vous ne dites pas que vous appliquez TOGAF, l'utilisation de quelques uns des principes pourrait améliorer fortement votre pratique.

Alors n'hésitez plus !


  





Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.

samedi 15 juin 2013

NetBeans : configure the IDE for extra productivity


Java IDEs are memory eaters.

If your NetBeans is working fine when using default configuration it may work better if you tune JVM memory a little bit.

Indeed, if NetBeans lacks of Java Heap, it can trigger many garbage collections and slow down the whole IDE.

I use a special configuration to enhance NetBeans.

You have to edit the netbeans.conf file which lies in NETBEANS_HOME/etc/ folder.

Add extra heap like this :

netbeans_default_options="-J-client -J-Xss2m -J-Xms32m  -J-Xmx1024m -J-XX:PermSize=32m -J-XX:MaxPermSize=192m  ..."


On Mac, for DMG install only, you have to access the NetBeans package content in order to edit the file : It's in /Applications/NetBeans/NetBeans 7.3.1.app/Contents/Resources/NetBeans/etc/ for instance.


Have fun, with this wonderful IDE !






Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.

JSF and AJAX : a happy wedding if you understand IDs management


JSF 2 brings AJAX support to a high level of productivity for server side development; but you have to understand some subtle mechanics to really enjoy it.

One of this mechanic is IDs management.

About IDs


IDs, like their names tell us, allow to identify components in the view.

Each component is in the view at a certain place, the whole is a tree of components.

Every ID must be unique.

When doing AJAX with JSF you have to use IDs for source of the request and target of the request.


Use case


Here is a sample page :

Loading ....



I want to refresh 3 areas when my AJAX request complete :
- output inside the  main form
- output2
- output3 inside a second form


Like an UNIX filesystem



Everything is in the ":" usage.

So what means the ":" char ?

The key is to consider it like the slah char in UNIX filesystem.


Component are like files, some are directories : they contain other components.
Some directories are special, they have an influence on client IDs computation.

These special components are  naming container, they give their IDs to their children as a prefix.

So if you inspect XHTML you can see mainform or secondform prefix on some children nodes.

When an AJAX request is running, the current context for ID computation is the nearest naming container in the hierarchy.

All IDs used in ajax tag without a ":" are evaluated from this starting point. This is the current directory.

The solution


In sample above, my AJAX tag must use the following IDs :



Loading ....

Why


1) What is the nearest naming container ?

It's mainform.

2) What is the relationship between output and mainform ?

output is a child node, I can target it directly and relatively:

./output -> output

3) What is the relationship between output2 and mainform ?

It's not in mainform, I must target it through the root of the tree, like I do with a filesystem :

/output2 -> :output2

4) What is the relationship between output3 and mainform ?

It's not in mainform, I must target it through the root of the tree but it's in secondform "directory" :

 /secondform/output3 -> :secondform:output3

Few tags are naming container :
- data
- form

But all composite components you create or use are naming containers !

Be careful when using these, they have a serious impact on how you have to write IDs in AJAX tags.

So, enjoy using both JSF and AJAX !





Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.

samedi 30 mars 2013

AngularJS Trick : posting data using url form encoded


AngularJS is a great framework : really, i mean it, i havent seen such beauty in client side development for years (say Ng for friends).

It gives you a clean MVC model far superior than Backbone.js for mono page app : most of its extraordinary effectiveness comes from coding by convention pattern.

The AngularJS framework does a lot for you behind the curtain.

But yes, there is always a but somewhere,  sometimes, it does too much (I use Angular 1.0.5 for this post) .

As AngularJS afficionados say, you can use AngularJS without JQuery, it's highly recomanded they say, as JQuery can twist the new thinking you must have when using AngularJS.

I agree with most of it.

But, when dealing with one of the most trivial task in RIA development, Ng is just too opinionated.

Indeed, Ng can do some REST with ease, but it does it his way and it's quite painful when you don't know the trick to do it the way you want.

By default, Ng uses JSON to send your request data.

If your REST service does not deal with such request,  then you're dead : 500 response code you will receive.

What must we do  ?

First import JQuery in your page.

Then, You have to configure the HTTP provider for your module and transform your request data using JQuery param function, ideally in the app.js file :

Loading ....


Now, you can issue a POST request with Ng's elegant way :


Loading ....



I think it's really bad to have to use JQuery for such trivial task.

Many Ng users have complained about it, and i hope the Ng Team will fix it.

Still, AngularJS is great, long life to AngularJS !





Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.


vendredi 8 mars 2013

Use Underscore.js template with JSP/JSF


Underscore.js is a great template engine, simple et efficient, easy to learn.

JSF 2 is one of the most interesting UI framework around, many powerful frameworks have been built on top of it : RichFaces, PrimeFaces, ...

Using both JSF and Underscore is a great opportunity to produce high valuable applications.

But Underscore.js use a default syntax which is not compliant with JSP/JSF compiler.

This syntax is known as ERB style, orignally designed for eRuby.

Here is a sample of this syntax :

Loading ....

JSP/JSF compiler does not taste the "<%" directive since it is a JSP directive or an invalid expression for JSF 2.

Fortunately, you can configure Underscore.js to use another syntax !

Here is new settings for Underscore.js (mustache syntax):

Loading ....

You must put this code in a JS , just before using Underscore.js.

Now, template is updated with new syntax :

Loading ....

Now, you can use Underscore in JSP or JSF 2 pages !






Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.


samedi 26 janvier 2013

HTML 5 Offline : Local Storage cleaner


I've built a small but useful Chrome extension to purge Local Storage.


So, here it is : Local Storage cleaner





You can find it on Chrome Web Store using  "Local Storage cleaner" words. Then choose Extension panel.

Enjoy !


This extension can be used in combination with Appcache Cleaner.






Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.


samedi 12 janvier 2013

Leveraging NetBeans completion for XHTML


The Story

This, started in december 2012 when Geertjan blogged about an article of mine.

This article, written in French, explained how one can build a completion on lang attribute in XHTML files for NetBeans 7.2.1.

As I stated in my article, some principles and code I used were quite generic enough to be used in other completion use cases.

Geertjan took my code and add a very important thing : annotations on top of it.

I pushed my code and Geertjan's idea to a higher level and here we are !


The Proof Of Concept

This new NetBeans POC API  is about using annotations to register completions on XHTML content.

A developer only need to focus on his completion need and has little to know about NetBeans APIs he should deal with if this new API did not exist.

The API code and some samples are on github.

It's only a proof of concept : I don't really know if this work should or should not be integrated in THE NetBeans official API.

All I can tell is this is far much easy to build an XHTML completion module with it than without it.

Plus, some principles could be used to leverage other NetBeans API like Hyperlink API.

First Sample

Here is a sample of a very simple completion use case.

NetBeans Platform is used as business application in a newspaper's redaction team. Journalists need to write XHTML page in 4 languages: French, Spanish, Italian, English.

Now, the NetBeans developer can do this with a very small effort.

He has to create a package info file in a NetBeans project module.

Then, let's annotate it :

Loading ....


Mastering content


One of the key concept of this API is CompletionItemData class.

This simple class provides you with common properties and behavior you need to implement more advanced completions.

Here is a class implementing CompletionItemDataProvider :

Loading ....


Now you have to declare its use in content attribute :


Loading ....

A la Camel URI

As you've probably noticed, the content attribute in AttributeCompletionRegistration annotation uses an  URI form.

It's most alike Camel uses it to configure endpoints. This pattern allows rich configuration in a compact form.

Some sample of content URI use :


Loading ....


In our newspaper application, the scheme part (here raw or bean) tells which CompletionService to use (a subinterface of CompletionItemDataProvider).

In our case bean scheme is selecting BeanCompletionService. This service delegates the CompletionItemData delivery to a class specified in URI specific part.

Here it is : mynewspaper.netbeans.completion.lang.LangCompletionItemDataProvider


Build your own completion service

The API provides you with the interface CompletionService.


Loading ....

You have to implement a class with this interface.

Your completion service should a have strong URI scheme to be clearly distinguished.

We choose lang here.


Loading ....

Java SPI is used to discover completion service at runtime.

So, you have to create a META-INF/services/org.netbeans.spi.editor.completion.xhtml.api.CompletionItemService file and in your NetBeans module project add the following line :


mynewspaper.netbeans.completion.lang.LangCompletionItemService


Define a complete action


As you can see in API source code, there is a CompleteAction interface.

A complete action is an action to execute when user select an item in the completion box.

Any CompletionItemData object can have its own.

There is one by default, which is assigned by implementation : when user select item, the value is inserted in current attribute.

But some CompleteItemData instance are not designed to update current document.

Just imagine, you want to add a new language code if a user types a code you don't have in your completion box.

You just add a CompletionItemData with a "Creates missing language" and a custom CompleteAction.

Loading ....


Conclusion

We have seen how it is easy to create XHTML completion for attribute.

You can use many concepts to achieve your goals :

- built in completion services : raw, csv, rest
- build a CompletionItemData provider and use bean completion service
- build a full completion service from scratch
- usage of CompleteAction for specific behaviors at selection





Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.


mercredi 9 janvier 2013

PYPL PopularitY of Programming Language index


J'avais blogué à propos de l'index TIOBE il y a quelques temps.

Je m'interrogeais sur la pertinence de cet index.

Je doute encore de la justesse du classement qui est proposé par TIOBE et nous allons voir pourquoi.

Il y a quelques temps la section Bugs et changes request de la page présentant le classement a attiré mon attention.

Présenté comme un bug par l'équipe TIOBE on pouvait trouver la déclaration suivante lors la mise à jour d'octobre 2012 :

The hits for +"Objective-C programming" appear to be counted for the programming language C as well. This holds for both Google and Yahoo. So the language C is overestimated in the TIOBE index. This will be fixed as of next month.

Bref, TIOBE avouait carrément qu'il y avait un gros soucis avec le classement du langage C et Objective C !

Ce que semble confirmer d'autres indicateurs pertinents comme les sites de recherche d'emploi, les forges de développement, ...

Depuis rien, ou presque une lente érosion de la popularité de C, les courbes C et Java semblant bientôt se recroiser à nouveau. Aucune information de TIOBE sur ce bug après cette publication d'Octobre.

Il est clair que si l'index était recalculé en prenant en compte les termes du bug alors il y aurait un chamboulement spectaculaire du classement. Il est probablement que TIOBE y perdrait sa crédibilité.

Un autre index a attiré mon attention PYPL.

Il propose me semble-t-il une utilisation plus fine des statistiques de Google. Plutôt que de considérer uniquement la masse de contenu il s'intéresse également à l'utilisation de ce contenu.

En effet, à quoi sert un contenu que personne ne lit ?

L'intérêt de cet index est de calculer la popularité des langages à partir d'un jeux de données que l'on peut reconstruire facilement ce qui n'est pas le cas de TIOBE.

Les résultats du classement sont plutôt très différents de ceux de TIOBE et peut être plus en rapport avec la réalité observable notamment au niveau du marché du travail :







A vous de vous faire votre opinion !







Contrat Creative Commons
the jee architect cookbook by Olivier SCHMITT est mis à disposition selon les termes de la licence Creative Commons Paternité - Pas d'Utilisation Commerciale - Pas de Modification 3.0 Unported.