Le weblogue de SeB

Les libellés, appelés également tags, sont très populaires actuellement. Mais sont-ils à même de remplacer les bonnes vieilles catégories ?

Sous l’impulsion du billet de David Latapie à propos des tags et catégories, voici un comparatif de ces deux systèmes de classification.

Définitions

• Une catégorie est un ensemble d’éléments regroupés sous un thème principal.
• Un libellé est un mot-clé qui caractérise un élément.

Différences

Les catégories se caractérisent par :

• Peu nombreuses : cela permet d’identifier rapidement les différentes thématiques
• Liens hiérarchiques essentiellement privés : elles ne sont pas vouées à être partagées
• Vision subjective puisque personnelle
• Définies avant les éléments : ces derniers sont choisis en fonction des catégories

Par opposition, les libellés se définissent par :

• Utilisés en grand nombre : afin de caractériser au mieux les éléments
• Liens transverses via un réseau : pour pour donner une dimension sociale (tels que les systèmes folsonomiques)
• Vision objective puisque communautaire
• Identifiés après les éléments : c’est ce qu’il ressort des éléments

Les méthodes de classifications

Les libellés donnent une vision moins claire que les catégories. De plus les catégories sont le résultat une réflexion en amont. Alors que les libellés représentent plus un état esprit : le ressenti à un instant.

Par contre, les libellés sont beaucoup plus faciles à gérer que les catégories. De plus, les libellés permettent de résoudre le problème de la classification des éléments qui soit peuvent être classés dans plusieurs catégories, soit ne correspondent à aucune catégorie.

Ces éléments de comparaison permettent de mettre en évidence que les catégories et les libellés n’ont pas tout à fait le même rôle. Et donc, il n’est pas anormal d’opter pour une combinaison de ces deux systèmes de classification. Les catégories permettent de mettre en place un système mieux réfléchi et plus posé. Et dans un même temps, les libellés apportent plus de souplesse et d’ouverture vers les autres.

A force de grandir, le projet commençait à être à l’étroit.

Hier soir, GWhere a changé d’hébergement. L’hébergeur est toujours le même, à savoir : OVH. La migration s’est très bien passée^[1].

La migration a été tellement rapide, que je ne pourrais même pas vous dire combien de temps ça a pris entre la commande de l’hébergement et la mise à disposition du nouvel espace d’hébergement. Encore une fois, bravo à l’équipe d’OVH^[2]. J’espère que vous n’avez pas été dérangé par la migration du site^[3].

De nouveaux projets devraient être mis en place sur cet hébergement. Donc, affaire à suivre…

Afin d’améliorer l’ergonomie de MS Office 2007, la compagnie a mis en place le mouse-tracking sur sa version 2003.

Présenté dernièrement, le mouse-tracking permet de mieux comprendre comment l’utilisateur utilise une interface. Ceci permet aux concepteurs d’interface d’améliorer l’ergonomie de leurs applications.

Vincent Maurin nous apprend que la société Microsoft a mis en place cette technique sur la version 2003 de leur Office^[1]. Ceci leur a permis de collecter des données sur près de 1,3 milliard de sessions MS Office 2003 et environ 350 millions de cliques dans les barres d’outils de MS Word !

Ces données ont permis de connaître :

• les barres outils ajoutées ou enlevées
• les raccourcis claviers les plus utilisés
• le nombre de dossier utilisés dans MS Outlook
• la taille des fenêtres
• pleins d’autres informations essentielles

Ces informations ont été rendues disponible par Jensen Harris.

Avez-vous confiance en votre mot de passe ?

On ne rappellera jamais assez l’importance du choix d’un mot de passe. Mais la fréquence de renouvellement du mot de passe est tout aussi importante que le choix du dit mot de passe. En effet, avec le temps un mot de passe devient moins sécurisé.

Pour vous en convaincre, savez-vous combien de temps faut-il pour cracker un mot de passe ? Terrifiant, non ? Après cette lecture, vous modifierez plus souvent vos mots de passe.

Existe-t-il encore des personnes qui en doutent ?

Connaissez-vous La Fraise ? Ce site propose la vente en ligne de T-Shirts. Le concept du site est très innovant, puisque c’est le consommateur qui décide de la collection qui sera mise au catalogue.

Olivier Martineau félicite Patrice Cassard, le créateur de l’entreprise, pour sa réussite et pour la transparence dont il fait preuve en communiquant sur les chiffres de son commerce !

De plus Blog eCommerce propose un dossier très instructif sur le fonctionnement et les chiffres de La Fraise.

Pour les personnes intéressées sur le sujet, P. Cassard explique la démarche dès le début et fait un bilan un an après.

Ces lectures devraient donner quelques pistes pour de futurs créateurs boutique électronique.

Lors de la réalisation d’un site web, il peut être intéressant d’implémenter sa propre page d’erreur 404.

Lorsqu’un utilisateur demande une page inexistante sur un site, le serveur HTTP retourne une erreur 404 dont le message est page non trouvée. Soit pour un aspect esthétique, soit dans un but statistique^[1], on peut être amené à créer sa page d’erreur HTTP personnalisée.

En prenant l’exemple de page écrites en PHP et exécutées sur le serveur HTTP Apache, il faut paramétrer le fichier .htaccess et d’écrire une page nommée erreur.php^[2].

Il faut ajouter cette ligne dans le fichier .htaccess :

ErrorDocument 404 http://www.mondomaine.com/erreur.php?code=404

La page erreur.php doit contenir le code suivant^[3] :

<html>
 	<head>
 		<title>Page d'erreur HTTP <?=code?></title>
 	</head>
 	<body>
 		Vous venez de rencontrer une erreur HTTP <?=code?> pour la page <?=$REQUEST_URI?>.
 	</body>
 </html>

Si l’utilisateur demande une page qui n’existe pas, il sera redirigé vers cette page. Par contre, la variable $REQUEST_URI retourne la valeur /erreur.php. Pour corriger ce problème et afficher correctement la page demandée et qui a provoqué l’erreur 404, il faut rectifier le fichier .htaccess ainsi :

ErrorDocument 404 /erreur.php?code=404

Maintenant la page d’erreur affiche correctement le nom de page source de l’erreur 404.

Pour finir, on peut estimer qu’il n’est pas très propre de véhiculer le code d’erreur HTTP dans l’URL de la page d’erreur. Heureusement, une variable PHP permet de connaître le code d’erreur HTTP. En reprenant l’exemple depuis le début, il faut implémenter la gestion des erreurs de la façon suivante.

Le fichier .htaccess se simplifie :

ErrorDocument 404 /erreur.php

Le fichier erreur.php doit être modifié pour utiliser la variable $_SERVER["REDIRECT_STATUS"] :

<html>
 	<head>
 		<title>Page d'erreur HTTP <?=$_SERVER["REDIRECT_STATUS"]?></title>
	</head>
<body>
Vous venez de rencontrer une erreur HTTP <?=$_SERVER["REDIRECT_STATUS"]?> pour la page <?=$REQUEST_URI?>.
</body>

</html>

Voici donc une méthode simple et efficace pour gérer les erreurs HTTP en PHP. Cet exemple n’est pas seulement valable pour les erreurs 404, mais pour toutes les erreurs HTTP telles que 401, 403, 500, …

Notes

[1] Ou pour surveiller ce qu’il se passe sur le site.

[2] Le nom choisi pour cette page est libre.

[3] Le code HTML est non-exhaustif car ce n’est pas le sujet de l’article.

Plusieurs solutions existent pour parcourir une interface Map. Mais sont-elles toujours optimales ?

En Java, l’interface Map permet de définir une liste d’association entre clés et valeurs. Ainsi à partir d’une clé, il est possible de retrouver la valeur correspondante.

Une bonne démarche pour parcourir un objet implémentant l’interface Map, est d’utiliser les itérateurs définis par l’interface Iterator. L’interface Map propose trois méthodes qui retournent une Collection à partir de laquelle il est possible d’accéder à un itérateur :

• public Set entrySet(); retourne la liste des couples clé/valeur
• public Set keySet(); donne la liste des clés
• public Collection values(); permet d’obtenir la liste des valeurs

Lorsque l’on parcourt une Map, il est souvent nécessaire de connaître à la fois la clé et la valeur. Beaucoup de personnes sont alors tenté d’écrire^[1] :

Map map;
for ( Iterator i = map.keySet().iterator(); i.hasNext();) {
 Cle cle = (Cle)i.next();
 Valeur valeur = (Valeur)map.get(cle);
 /* Utilisation des objets cle et valeur */
}

Ce bout de code fonctionne très bien. Pourtant il n’est pas optimal. En effet, on commence par récupérer la liste des clés. Puis pour chaque clé, on recherche la valeur correspondante. Or, il est préférable de récupérer en une seule passe les clés et les valeurs. Pour cela il faut faire appel à la méthode entrySet() :

Map map;
for ( Iterator i = map.entrySet().iterator(); i.hasNext();) {
 Entry couple = (Entry)i.next();
 Cle cle = (Cle)coupe.getKey();
 Valeur valeur = (Valeur)couple.getValue();
 /* Utilisation des objets cle et valeur */
}

Cet exemple, montre qu’il faut prendre le temps de lire la JavaDoc. Ceci afin d’utiliser de façon optimale l’API très riche offerte par le JDK. Ce type d’optimisation permet parfois de gagner énormément en performance. Car c’est le genre de boucle qui revient souvent dans le code source.

Plusieurs syntaxes existent pour comparer des objets String. Mais lequel faut-il utiliser ?

Tout d’abord, mettons de côté l’opérateur == qui compare si les références des deux objets pour vérifier s’ils correspondent à la même instance.

La méthode String.equals() vérifie l’égalité de deux chaînes de caractères. Alors que la méthode String.compareTo() calcule la différence entre deux chaînes de caractères. Il faut savoir que les deux test suivants sont équivalents^[1] :

• String str = "ma chaine";if ( str.equals("mot magic")) {/*...*/}
• String str = "ma chaine";if ( str.compareTo("mot magic")==0) {/*...*/}

Laquelle de ces deux méthodes est la plus performante pour vérifier l’égalité ? Il paraît évident que la méthode equals doit être plus rapide que la méthode compareTo puisque la première doit s’arrêter dès qu’une différence est trouvée alors que la seconde calcule la différence. Or la méthode compareTo s’arrête également dès la première différence trouvée.

De plus, dans les anciennes version de Java, la méthode equals utilisait la méthode compareTo. Depuis elle a été optimisée et effectue ses contrôles elle-même. Par exemple, elle vérifie si les deux objets pointent sur la même instance ou bien si les chaînes de caractères ont la même longueur. Dans ces cas particuliers, la méthode equals se révèle nettement plus performante.

Par contre, pour des chaînes de caractères de même longueur et ne pointant pas sur la même instance^[2], la méthode compareTo donne de bien meilleures performances^[3].