Blog de David Côme

De l’utilisation des formats propriétaires.

davidbrcz — Fri, 10 Apr 2009 22:28:51 +0000

Aujourd’hui, il est m’est arrivé une petite anecdote. J’étais au CDI tranquillement en train de chercher du vocabulaire sur le site wordreference.com (au passage, très bon site) quand une personne m’interpelle et me demande si je peux échanger mon poste avec elle. N’ayant besoin que de firefox, je le fais sans problème. Quelques minutes après, je regarde le logiciel dont elle avait besoin: Office 2007 pour gérer le format docx.

Je me permis de faire remarquer à cette personne qu’être dépendant d’un format spécial, c’est du suicide informatique. Regardons pourquoi.

Il faut avant toute chose remarquer que les données sont en informatique notre bien le plus précieux, ce sont elles qui sont importantes. Perdre des données peut signifier que perdre des quantités phénoménales d’argent. Une fois ceci compris, ce qui importe c’est comment pouvons nous exploiter nos données, c’est à dire, avec quels logiciels pouvons nous les lire et là se pose la question du format des données.

Si celles si sont dans un format dit ouvert ou libre, tout le monde a accès aux spécifications du format et peut créer un logiciel pour travailler avec ces données. Prenons Open Office (qui offre aussi un pare-feu, comme tout le monde le sais). Le principal format utilisé par Open Office est le format odf (pour Open Document Format). Le format est disponible librement en téléchargement et est implémentable gratuitement par tous, comme le précisent les termes de la licence: on le retrouve par exemple dans StarOffice, KWord ou encore Abiword. On peut donc dire que la pérennité des données est assurée, on est sûr de pouvoir les lire un jour.

En revanche, si ces données sont dans un format dit fermé ou propriétaire, seul le fournisseur du logiciel a accès aux spécifications du format. Seul lui est en mesure de fournir un logiciel pour exploiter les données. Il est libre de faire ce qu’il veut avec. Par exemple, il peut arrêter de produire le logiciel du jour au lendemain, modifier le logiciel pour ne plus lire les documents et faire payer 150€ par licence pour que le logiciel puisse à nouveau lire les données. En somme, c’est LUI qui est le vrai propriétaire de VOS données, pas vous. En utilisant des formats propriétaires, vous enfermez vos données dans une cage dont la clé ne vous est que prêtée sans aucun contrat. D’ailleurs, si vous voulez lire vos données sur un autre PC, il vous faut le logiciel de l’éditeur, ce qui implique de repayer une licence pour lire VOS données alors que vous en avez déjà une sur votre poste.

En conclusion, j’espère que ce petit billet vous aura permis de prendre conscience du danger économique que représentent les formats propriétaires et je ne pourrai que vous inciter à utiliser des formats libres.

Installation d’une webcam Logitech E2500 sous Debian.

davidbrcz — Fri, 10 Apr 2009 18:51:21 +0000

J’ai récemment fait l’acquisition d’une webcam Logitech E2500 et à ma grande honte, je n’ai pas vérifié si elle était compatible UVC avant. Donc une fois sortie de sa boite, aucune réaction. Mais il y a une petite manipulation pour la faire marcher:

1) Récupérez les sources du module gspca que votre distribution fournit.
2) Récupérez ce patch
3) Appliquez le patch au fichier gspca_core.c via la commande patch.
4) Construisez le module en lancant en root le script gspca_build
5) Branchez votre webcam et vous devriez voir apparaitre video0 dans /dev

Si ca ne marche pas, vérifiez qu’il n’existe pas un autre module gspca.ko.
Pour les différencier, il suffit d’utiliser md5sum et remplacer l’ancien via un coup de cp (ou mv si vous souhaitez conserver l’ancien).

Enjoy it !

Comment éviter que les énumérations polluent ?

davidbrcz — Sun, 03 Aug 2008 21:20:34 +0000

Les énumérations peuvent être source de problèmes de pollution de portée, comment les résoudres ?

Un rappel sur les énumérations
Les énumérations sont un outil très puissant puisqu’elle permettent de définir des types n’acceptant que certaines valeurs bien précises.

Exemple

enum Carte {Pique,Coeur,Carreau, Trefle};

va définir un type Carte ne pouvant prendre que les valeurs Pique,Coeur,Carreau ou encore Trefle.

Il est aussi possible de définir une énumération anonyme. Dans ce cas, les valeurs dans l’énumération sont tout simplement des constantes.
Exemple:
enum {alpha,beta,release}; va définir 3 constantes : alpha, beta et release.

Mais dans tous les cas, les valeurs définies seront dans le namespace global. Autrement dit,si on souhaite avoir une constante de même nom dans deux énumérations différentes, ce n’est pas possible.

Exemple:

enum Fruit {Pomme, Orange};
enum Couleur {Couleur, Orange}; //ne compilera pas, Orange est deja defini.

Ce n’est pas très pratique, avouons le. Comment peut-on remédier à cela ?

Limiter la portée des énumérations globales
Comme nous l’avons vu, une énumération définie le namespace globale va le polluer entiérement. Ce que propose le C++ pour éviter les conflits de nom est de pouvoir créer son propre namespace. le namespace (ou est espace de nom en français), est un mécanisme permettant de regrouper dans une même portée un ensemble de classes, fonctions ou encore d’objets ayant des relations en communs. Le namespace le plus connu est std: il représente le namespace de la bibliothèque standard.

Donc pour résoudre notre problème de conflit de nom, il suffit de définir notre énumération dans un namespace personnel. On appel souvent ce namespace de la même façon que l’énumération de façon à pouvoir écrire des choses comme:

Carte::Type c= Carte::Pique;
avec la définition de l’énumération sous la forme:

namespace Carte
{
enum Type {Pique,Trefle,Coeur,Carreau};
}

Limiter la portée des énumérations locales à une classe
Cette solution est adaptée aux énumérations globales, mais que se passe t’il pour les énumérations locales à une classe ?

En effet, en C++ on peut définir une énumération dans une classe.
Exemple:

//classe represantant un fruit avec un colorant alimentaire
class FruitColore
{
enum Fruit {Pomme, Orange};
enum Couleur {Vert,Orange};
};

Mais cette classe ne compilera pas, à cause de la redéfinition d’orange. et on ne peut pas passer par un namespace, puisque un namespace dans une classe n’aurait pas beaucoup de sens.

La solution est de passer par les structures. En definissant l’énumération dans une structure, on limite sa portée à la dite structure.

Exemple:

class FruitColore
{
struct Fruit {enum {Pomme, Orange};};
struct Couleur {enum {Vert,Orange};};
};

Pour créer des types et non juste définir des constantes, il suffit de rajouter un nom à l’énumération.
Exemple:

class FruitColore
{
struct Fruit {enum type {Pomme, Orange};};
struct Couleur {enum type {Vert,Orange};};
};
void foo(FruitColore::Fruit::type t)
{
std::cout<<"t= "< }

Conclusion
L’utilisation des namespace et de structure pour limiter la portée des énumérations est quelque chose de bien pratique sur plusieurs points, mais amené à disparaitre à cause des class enum de C++0x, qui feront ce que nous avons fait (et même plus) de façon bien plus rapide.

Sortie de Ultimate C++ 2008.1

davidbrcz — Thu, 07 Aug 2008 08:43:35 +0000

Aujourd’hui, un petit billet pour présenter Ultimate C++, qui vient de sortir sa nouvelle version.

Ultimate C++ est un RAD comprenant en autre un IDE, une bibliothèque touche à tout (GUI, SQl,…), un designer; le tout étant disponible sur de multiples plateformes sous une licence libre (BSD). L’IDE se veut polyvalent et puissant en intégrant un système d’aide pour la bibliothèque, des technologies pour accélérer la recompilation d’un projet, en étant capable de travailler avec les principaux compilateurs du marché (g++, visual,…)

Liste d’un partie des nouveautés:
L’annonce de la release sur Usenet avance 200 nouveautés dont:

Une nouvelle implémenation beaucoup plus performante des String/WString
Présence d’un nouvel allocateur de tas de haute-performance (presque) sans lock
Un support amélioré du multi-thread
une classe CoWork pour aider à paralléliser le code.
Un support unifié du Drag & Drop
Le support de PostgreSQL
Le support de Win64 support (sauf le debugger)
une classe QuickTabs
HeaderCtrl peut maintenant déplacer les onglets
ArrayCtrl trie automatiquement les collones
Le Look&feel de Chameleon a été amélioré sous GTK et Vista
la documentation (Topic++) fait maintenant partie intégrante de l’IDE.

Pour installer, rien de plus simple: des paquets sont disponibles. Il suffit de télécharger celui qui correspond à votre distribution. Au pire, il reste les sources à compiler.

Du coté des principaux regrets, on peut noter la structure du code de la bibliothèque, qui ressemble à celle de wxwidget (moi pro-Qt ? Nan, du tout) et un IDE qui semble, après un test rapide, ne pas être des plus ergonomique.

La guerre des plateformes mobiles.

davidbrcz — Mon, 04 Aug 2008 17:44:38 +0000

Il y a encore peu de temps, les plateformes mobiles disponibles étaient assez restreintes : d’un coté Microsoft avec Windows CE, d’un autre coté Symbian

Mais ce temps est révolu …

En effet, depuis novembre 2007, Google propose sa propre plateforme: Android.
Android est une plateforme libre basée sur un noyau linux mettant à disposition des développeurs un SDK pour développer des applications. Pour augmenter l’attrait des développeurs pour sa plateforme, google a même organisé un concours de développement de logiciels sur Android, avec à la clé 10 millions de dollars pour chaque développeur d’une application primée.

Mais depuis très peu de temps, un autre concurrent est arrivé. Il s’agit du consortium Limo, qui vise à développer un système d’exploitation basé sur Linux et adapté aux téléphones portables et autres PDAs. Bien que Limo ne soit pas opérationnel, il semble très prometteur.

On voit donc qu’on dispose de 3 plateformes mobiles open-source (Nokia s’est engagé à rendre Symbian open-source) , toutes les trois prometteuses (même si Symbian à déjà fait ses preuves) avec un certain nombre de membres en communs.

La guerre des plateformes ne fait que commencer.