Mardi 20 octobre 2009
Well, you might want to see where it all started : here. For those who do not want to jump, here is a short story board : since symfony 1.3, it is possible to configure symfony to generate URLs for the file names in the exception screens.  I, of course, wanted to do the same thing N1ko does but in Vim and Linux.

In the settings.yml of your application, you can add the following setting for the dev environment :

file_link_format:       "vim://%f:%l"

It will make symfony's exceptions like this :


You see, firefox now displays URLs beginning with vim:// Things become more complicated when you want to configure something somewhere to launch vim when you click on this link.

The first thing is : I am (fortunately) not running MacOS with aqua, nor (sadely) KDE but GNOME ... how the hell can I tell GNOME to do this ? This is still mystery to me. I know it is probably a joke for experienced KDE guys where every ressource is available via an URL but here ... not a clue.

Second thing : firefox. I can tell firefox to launch an editor when I click on the link ! Easy task. Open the about:config in the URL bar and add the 2 following values :

network.protocol-handler.external.vim         boolean      true network.protocol

      handler.app.vim                                                 string          ~/bin/ff_vim


and create the ff_vim script to launch gvim with the according file. But we can do better ! Vim support client server mode so it is possible to open this file in a remote vim session. Usually this is the session you are currentely using to develop on your project. Let's have an example : you want to work on your project, just lunch a Vim session with the --servername option to create a server session :

vim --servername VIM

You can add an exception somewhere to make our application to fail and display the famous exception screen. Edit the ff_vim script like the following :
#!/bin/bash

args=$*;

if [ -z "${args[*]}" ];
then
  echo "no URL given"
  exit 1
fi
# strip the vim://
url=${args[*]:6};

# grab the left part of the :
file=$(echo $url | awk -F':' '{print $1}')

# there might be a servername separated with @
servername=$(echo $file | awk -F'@' '{print $2}')

# if not, the session name is VIM
servername=${servername:="VIM"}
servername="--servername $servername"

# grab the file
file=$(echo $file | awk -F'@' '{print $1}')

# grab the line number and set the option if any
line=$(echo $url | awk -F':' '{print $2}')
line=${line:+"+${line}"}

gvim $servername --remote-tab-silent $line $file

What happens here ? We do grab the file and the optional line number and session name from the URL and launch gvim with the «remote» option. This means if you have a Vim session running in a terminal it will open a new tab with the file at the given location, otherwise this will pop up a gvim window with the file at the right place.

 

Note that you can do the same thing for x-debug error messages ! This awsome trick is well explained here.

Par greg
Ecrire un commentaire - Voir les commentaires - Recommander
Samedi 10 octobre 2009
Hi,

Every PHP developper who had one day to deal with a LDAP tree realized sadly there was no ready to use library to do all the dirty work. That always meant back the the PHP doc and re invent the wheel over and over again.
As it is more often people ask me about symfony and LDAP, I decided to implement an abstration layer for LDAP to make queries as simple as it is today with ORMs like Propel or Doctrine : slapOrm.

It is still in early stage of development : it can generate model class from a schema file, perform complex queries but can write to the LDAP nor generate forms from schema yet. Ultimately I wish it could handle relations between LDAP objects but I do want to develop it slowly, ensuring everthing is well designed and rock solid before moving on complex features. As I am far away from being a LDAP expert, I want this tool to be a convenient way to deal with LDAP without hassle. Every feedback will be welcome.

Installing slapOrmPlugin

Grab the archive on GitHub and extract it in you project's plugin directory. Clear the cache and here you go !

The documentation is available here
Par greg - Publié dans : symfony - Communauté : symfony
Ecrire un commentaire - Voir les commentaires - Recommander
Mercredi 30 septembre 2009
Petit mot rapide pour vous dire qu'un first jeudi (donc le premier demain) est organisé à Nantes au clou qui r'ssort 5 rue st Léonard à partir de 19h. Si vous êtes dans le coin, passez donc prendre une planchette !

/function^MVj%zfj
Par greg
Ecrire un commentaire - Voir les commentaires - Recommander
Dimanche 27 septembre 2009
C'est une des questions que je me pose en ce moment ... je ne vous cache pas que ce blog est au point mort avec les quelques projets qui m'occupaient. Il est donc moment de mettre un terme à cette partie de mon existence de geek pour muer en autre chose. Fin 2009, il n'y aura donc que du neuf !!

Un vrai blog ailleurs, le projet de livre Vim accessible en ligne en tant que projet colaboratif ainsi qu'en PDF. Le neuf a déjà un peu pris forme : un petit projet de couche d'abstraction LDAP qui s'appelle slapOrm (toujours à l'état expérimental pour l'instant).

Puisque ce blog n'est rien sans un petit tip vim : pour afficher l'ensemble des signatures de fonctions et attributs publics d'une classe (ou d'un fichier) avec leur numéro de ligne : «:g:public»
Par greg
Ecrire un commentaire - Voir les commentaires - Recommander
Vendredi 12 juin 2009
Pour tous les symfonistes (et quelques autres), manipuler des fichiers yml d'une bonne centaine de lignes minimum est une activité normale et quotidienne, indispensable pour se mettre de bonne humeur au réveil. Pour ceux qui ne connaitraient pas le parser Yaml, il s'agit d'un animal susceptible, ne tolérant que les indentations de 2 espaces et haïssant les tabulations au point de refuser de parcourir un fichier en contenant (même une petite). Il est assez facile de configurer Vim une bonne fois pour toute afin de proposer les options suivantes :

- indentation par défaut : 2 espaces
- transforme les tabulations en 2 espaces
- affiche les caractères de fin de ligne, les tabulations et espaces entre le dernier caractère et la fin de la ligne

set tabstop=2

      set shiftwidth=2

      set expandtab

      set listchars=eol:¤,trail:-


Les listchars ne seront affichés que si vous le demandez avec un «set list» pour le désactiver : «set nolist»

Cela évite les problèmes les plus courants. Par contre, dès que vos Yml deviennent consistants, il devient délicat de repérer les niveaux d'imbrication des blocs. Il est pour cela possible de surligner la ligne et la colonne courante pendant le mode édition. Vim vous permet en effet de modifier sa conf suite à un évènement. Demandez le surlignage lors du passage en mode édition et seulement pour les fichiers Yml pour les colonnes :

" Changement de configuration lors des transitions

       " mode commande & mode insertion

       autocmd insertLeave * set nocursorline

       autocmd insertEnter * set cursorline

       autocmd insertLeave *.yml set nocursorcolumn

       autocmd insertEnter *.yml set cursorcolumn

       "  Le choix des couleurs...

       highlight CursorLine                    cterm=none ctermbg=DarkBlue

       highlight CursorColumn                  cterm=none ctermbg=DarkRed



Et voila le travail, en mode insertion, les lignes sont surlignées en bleu et dans les fichiers Yml uniquement, la colonne courante est marquée en rouge pour permettre de voir rapidement le niveau d'indentation des blocs :


Par greg - Publié dans : vim
Ecrire un commentaire - Voir les commentaires - Recommander
Mardi 26 mai 2009
Bonjour à toutes et tous,

Je sors de ma grotte pour dans un premier temps parler du symfony live qui aura lieu à Paris les 11 et 12 juin prochains. Ce sera l'occasion d'écouter plein de conférences qui tourneront autour des avantages que procure le framework coté technique d'une part et des retours d'expérience de grand comptes sur le sujet. Les confs techniques seront menées par quelques brillants Sensiomen et quelques personnes (non moins brillantes) de l'AFUP, de clever age etc etc. Pour le programme, c'est par ici et les inscriptions c'est par là.

Une fois ce coup de pub passé, peut être êtes vous curieux de savoir ce qui me tient loin de mon clavier ces derniers temps ...



C'est effectivement à mi chemin entre l'apprentissage du russe et l'histoire de la conquête spatiale : l'électronique des tubes. Le fer à souder à pris la place de la souris (quoique la souris avec Vim... ) enfin bref ... ça reviendra.

Dernier point pour ceux qui savent qu'il ne peut y avoir de post sur ce blog sans un Tips Vim, le bouquin sur Vim a dépassé ses 35 pages et j'envisage de le libérer sous une forme LaTeX ou Wiki pour le rendre participatif mais un gros travail de remaniement reste à faire...

Ah ... le Tips Vim : dans une fonction et/ou méthode, le curser sur une variable : «gd» vous permettra d'atteindre la définition de cette variable (ie première affectation ou déclaration) ... gd pour Goto Definition évidemment.

Par greg
Ecrire un commentaire - Voir les 2 commentaires - Recommander
Jeudi 15 janvier 2009
Bonsoir à tous,

D'abord la basherie

entre deux articles sur Doctrine, je profite de quelques minutes de répis pour vous soumettre (enfin) la basherie dont je me sers depuis quelques semaines maintenant : la récupération des arguments de la ligne de commande précédente.

Vous pouvez récupérer de façon simple à l'aide de l'opérateur !:n (ou n est un entier) le nième argument de la ligne de commande précédente. C'est très pratique car d'une commande à l'autre on se sert souvent deux fois de mêmes arguments, typiquement, bouger un fichier et faire un lien symbolique dessus :
shell$ mv frontend.php frontend_prod.php
shell$ ln -s frontend_dev.php !:1
ln -s frontend_dev.php frontend.php

Le shell est en plus assez sympa pour vous afficher l'expansion réalisée sous votre commande, on ne pourra pas dire que bash n'est pas user-friendly sur le coup.

Puis les bouts de Vim

Deux nouvelles choses sont venues agrémenter ma vie de Vimiste ces derniers mois. La première et pas des moindres dans mon travail de symfoniste est l'utilisation des marqueurs majuscules. Les marqueurs majuscules fonctionnent exactements comme leurs homonymes minuscules à part qu'ils ont la particularité d'être persistants et multi-fichiers ... je m'explique : une fois placés, à l'aide d'un «mX» ou X est le marqueur, les marqueurs suivants par exemple dans un projet symfony :

marqueur pseudo fichier
S Schéma /config/schema.yml
F Fixtures /data/fixtures/fixtures.yml
A Action /apps/appli_courante/modules/module_courant/actions/actions.class.php
R Routing /apps/appli_courante/config/routing.yml

Etc etc ... Cela veut dire que si je veux jeter un coup d'oeil ou modifier le routing, un coup de «'R» voila le fichier chargé dans mon éditeur. Imbattable et cela ne pose aucun problème avec l'utilisation de Project.

 Les admins système préfèreront sans doute mettre des marqueurs sur les fichiers de conf d'Apache ou Postgresql en choisissant judicieusement les marqueurs A et P par exemple ... Comme ces marqueurs sont persistants il est inutile de les remettre à chaque fois que vous lancez Vim.

Deuxième petite chose intéressante : la navigation entre les onglets grâce à «gt» et «gT» (Go Tab) qui facilite quand même grandement la vie.

@bientôt.
Par greg - Publié dans : vim
Ecrire un commentaire - Voir les 3 commentaires - Recommander
Jeudi 8 janvier 2009
Hello, this is time for the second article on Doctrine with symfony about inheritance this time. As I am used to Postgresql's inheritance mechanism, I was curious as Doctrine proposes 3 ways to create inheritance with your objects model :
  • simple inheritance
  • concrete inheritance
  • column aggregation inheritance
Let's (again) take an example: we want to create an application for a show that rents bikes, motorcycles and maybe more. We can say, our shop rents vehicules. All of the vehicules can be one of bike, motorcycle, car or whatever. We can easily understand a car is different from a bike and they do not have the same caracteristics.

The first step is to create 2 tables, one vehicle and one bicycle table:
config/doctrine/schema.yml:
Vehicle:
tableName: vehicle
actAs: [Timestampable]
columns:
ref: { type: char(6), primary: true }
brand: { type: varchar(255), notnull: true }
Bicycle:
inheritance: { type: simple, extends: Vehicle }
columns:
bike_type: { type: enum, values: [city, mountain, race], default: city, notnull: true }
gears: { type: integer(32), default: 1, notnull: true }
seats: { type: integer(4), default: 1, notnull: true }
checks:
gears_min: gears > 0
seats_min: seats >


We see here, we have defined a simple inheritance. So what did Doctrine ?
data/sql/schema.sql:
CREATE TABLE vehicle (
ref CHAR(6),
brand VARCHAR(255) NOT NULL,
bike_type VARCHAR(255) DEFAULT 'city' NOT NULL,
gears BIGINT DEFAULT 1 NOT NULL,
seats INT DEFAULT 1 NOT NULL,
created_at TIMESTAMP without time zone,
updated_at TIMESTAMP without time zone,
PRIMARY KEY(ref)
);
(Our check statements do no appear) It sounds rather limited but let's see what we can do with that, assuming we add 2 bikes in the database using fixtures:
./symfony doctrine:dql "SELECT * FROM Bicycle"
>> doctrine executing dql query
DQL: SELECT * FROM Bicycle
found 2 results
-
ref: BK0478
brand: peugeot
bike_type: city
gears: '4'
seats: 1
created_at: '2009-01-04 17:18:25'
updated_at: '2009-01-04 17:18:25'
-
ref: BK0734
brand: raleigh
bike_type: mountain
gears: '21'
seats: 1
created_at: '2009-01-04 17:18:25'
updated_at: '2009-01-04 17:18:25

This isn't really an inheritance mechanism because the children doesn't inherit from its parent. It is more like the parent get richer with every child classes. This may work with very simple cases because in this application, the motorcycle may have columns with «not null» attributes that bikes will never comply with. This isn't really what we are looking for.

Let's change our schema to use the concrete inhéritance :
config/doctrine/schema.yml:
Bicycle:
inheritance: { type: concrete, extends: Vehicle }
Launche the build-all-reload and see what we have:
data/sql/schema.sql:
CREATE TABLE vehicle (
ref CHAR(6),
brand VARCHAR(255) NOT NULL,
created_at TIMESTAMP without time zone,
updated_at TIMESTAMP without time zone,
PRIMARY KEY(ref)
);

CREATE TABLE bicycle (
ref CHAR(6),
brand VARCHAR(255) NOT NULL,
bike_type VARCHAR(255) DEFAULT 'city' NOT NULL,
gears BIGINT DEFAULT 1 NOT NULL,
seats INT DEFAULT 1 NOT NULL,
created_at TIMESTAMP without time zone,
updated_at TIMESTAMP without time zone,
PRIMARY KEY(ref),
CHECK (gears > 0),
CHECK (seats > 0)
);

It sounds like Doctrine has created two tables and wants to handle the inheritance by itself. Let's see what we have once the fixtures are loaded:
In our database:
dbtest=> \d
List of relations
Schema | Name | Type | Owner
--------+---------+-------+-------
public | bicycle | table | toto
public | vehicle | table | toto
(2 rows)

dbtest=> SELECT * FROM vehicle ;
ref | brand | created_at | updated_at
-----+-------+------------+------------
(0 rows)



dbtest=> SELECT * FROM bicycle ;
ref | brand | bike_type | gears | seats | created_at | updated_at
--------+---------+-----------+-------+-------+---------------------+---------------------
BK0478 | peugeot | city | 4 | 1 | 2009-01-04 17:25:26 | 2009-01-04 17:25:26
BK0734 | raleigh | mountain | 21 | 1 | 2009-01-04 17:25:26 | 2009-01-04 17:25:26
(2 rows)



We can see we have 2 bikes but it also appears we have no vehicules ! So Doctrine does not handle the inheritance by itself, if we want to have 2 bikes and also say we have 2 vehicles we have to overload the Bicycle definition. The other solution is to declare the Vehicle as an abstract class:
config/doctrine/schema.yml:
Vehicle:
tableName: vehicle
abstract: true

But this seems not to work (or I missunderstood the doc) because the table definition is still present in the SQL...

Anyway, I am now able to create a motorbike table adding the following to
config/doctrine/schema.yml:
Motorcycle:
inheritance: { type: concrete, extends: Vehicle }
columns:
type: { type: enum, values: [scooter, roadster, city], notnull: true, default: scooter }
cylinder: { type: integer, notnull: true }
plate: { type: string(11), notnull: true, unique: true }
checks:
cylinder_min: cylinder > 0
plate_format: plate ~ \'[0-9]{1,4}\\-[A-Z]{2,3}\\-[0-9]{1,2}\

So after adding some fixtures I have 2 tables with independant data:
dbtest=> SELECT * FROM motorcycle ;
ref | brand | type | cylinder | plate | created_at | updated_at
--------+--------+---------+----------+------------+---------------------+---------------------
MB1837 | vespa | scooter | 125 | 324-MA-92 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
MB6430 | yamaha | city | 750 | 2301-ZC-60 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
(2 rows)



dbtest=> SELECT * FROM bicycle ;

ref | brand | bike_type | gears | seats | created_at | updated_at
--------+---------+-----------+-------+-------+---------------------+---------------------
BK0478 | peugeot | city | 4 | 1 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
BK0734 | raleigh | mountain | 21 | 1 | 2009-01-08 19:37:10 | 2009-01-08 19:37:10
(2 rows)



dbtest=> SELECT * FROM vehicle ;
ref | brand | created_at | updated_at
-----+-------+------------+------------
(0 rows)



If I try to count the vehicles I have with a DQL query it would not be as simple as:
test$ ./symfony doctrine:dql "SELECT * FROM Vehicle"
>> doctrine executing dql query
DQL: SELECT * FROM Vehicle
>> doctrine no results found

Let's then try the last type of inheritance: the columns aggregation.

Bicycle:
inheritance: { type: column_aggregation, extends: Vehicle, keyField: type, keyValue: bicycle }
For the bicycles and
Motorcycle:
inheritance: { type: column_aggregation, extends: Vehicle, keyField: type, keyValue: motorbike }
for the motorbikes.

Then doctrine complains it cannot load the data because constraints. If I go and have a check at the database I see there is only one table with all the columns but with an extra column named type and none of my sql constraints:
dbtest=> SELECT * FROM vehicle ;
ref | brand | type | bike_type | gears | seats | cylinder | plate | created_at | updated_at
-----+-------+------+-----------+-------+-------+----------+-------+------------+------------
(0 rows)
At the end of this testing phase I am a bit confused about what these types of inheritance stand for. I am not sure I will ever use one of those. I was expecting Doctrine to have like a PHP implementation of what Postgresql's inheritance system is without the problems it has ... or maybe I am missing something :o)

Par greg - Publié dans : symfony
Ecrire un commentaire - Voir les 4 commentaires - Recommander
Vendredi 2 janvier 2009
Here is the first sequel of my experiments using Doctrine with symfony 1.2. I will go trough 4 chapters that I found interesting to test :
- Using postgresql's constraints
- Using inheritance
- Different types of relationship
- Playing with DQL

The basics of using Doctrine will not be described here, there are plenty of good docs on the web (at least here or here) that show how to enable doctrine and how to use it within symfony. I will spend time on some precise points.

Using postgresql's constraints

One more time, this is the place to say constraints are not implemented to turn developers'life into hell. There are here to report discrepencies as soon as possible, it is like turning on the warnings when you are developping, it helps you.
That's one of the very good news using Doctrine with symfony : the abitlity to handle databases's constraints. The other good news is, some of the constraints will be automatically implemented in the according forms ! Let's see that with the following example :

config/doctrine/schema.yml:
Employee:
tableName: employee
columns:
ref: { type: char(6), primary: true, notnull: true }
first_name: { type: string(50), notnull: true }
last_name: { type: string(50), notnull: true }
birthdate: { type: timestamp, notnull: true }
hiredate: { type: timestamp, notnull: true }
email: { type: string(100), notnull: true }
Here, we want to store some data about employees of a company. If we set that schema.yml up in the «config/doctrine» directory and run a «symfony doctrine:build-all» we can see the following result :

lib/form/doctrine/base/BaseEmployeeForm.class.php:
$this->setValidators(array(
'ref' => new sfValidatorDoctrineChoice(array('model' => 'Employee', 'column' => 'ref', 'required' => false)),
'first_name' => new sfValidatorString(array('max_length' => 50)),
'last_name' => new sfValidatorString(array('max_length' => 50)),
'birthdate' => new sfValidatorDateTime(),
'hiredate' => new sfValidatorDateTime(),
'email' => new sfValidatorString(array('max_length' => 100)),
));
data/sql/schema.sql:
CREATE TABLE employee (
ref CHAR(6),
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
birthdate TIMESTAMP without time zone NOT NULL,
hiredate TIMESTAMP without time zone NOT NULL,
email VARCHAR(100) NOT NULL,
PRIMARY KEY(ref)
);

We can see here the default behavior we are already used to. Let's now say the «ref» field has to be a 6 chars identifier with 2 uppercase letters and 4 digits, the «birthdate» cannot be a date older than the «hiredate» and the «email» has to be a real life email address.
Doctrine allows to use database contraints with the «checks» keyword. Our schema becomes :

config/doctrine/schema.yml:

Employee:
tableName: employee
columns:
ref: { type: char(6), primary: true, notnull: true }
first_name: { type: string(50), notnull: true }
last_name: { type: string(50), notnull: true }
birthdate: { type: timestamp, notnull: true }
hiredate: { type: timestamp, notnull: true }
email: { type: string(100), notnull: true }
checks:
correct_dates: hiredate > birthdate
ref_valid: ref ~ \'[A-Z]{2}[0-9]{4}\'
Now we can see the following result:

data/sql/schema.sql:

CREATE TABLE employee (
ref CHAR(6),
first_name VARCHAR(50) NOT NULL,
last_name VARCHAR(50) NOT NULL,
birthdate TIMESTAMP without time zone NOT NULL,
hiredate TIMESTAMP without time zone NOT NULL,
email VARCHAR(100) NOT NULL,
PRIMARY KEY(ref),
CHECK (hiredate > birthdate),
CHECK (ref ~ '[A-Z]{2}[0-9]{4}')
);

And no change in lib/form/doctrine/base/BaseEmployeeForm.class.php.
This means the constraints we just set are passed "as is" to the database which is very handy if we need to use database's functions to check the integrity of our data. In an other hand, Doctrine does not set any symfony validator to automatically configure our forms.
Be sure to escape quotes in the constraint definition in the «schema.yml» because it will be imported as is in the php file :

lib/model/doctrine/base/BaseEmployee.class.php:
    $this->check('hiredate > birthdate');
$this->check('ref ~ \'[A-Z]{2}[0-9]{4}\'');
So, how can we tell Doctrine to set up the validators for us to use in symfony forms ? Well, Doctrine allows us to easily declare application level constraints (See official documentation).

Change the email line in the config/doctrine/schema.yml:
email:      { type: string(100), notnull: true, email: true }
and re launch the «doctrine:build-all» command. You should see the following change in the lib/form/doctrine/base/BaseEmployeeForm.class.php:
'email'      => new sfValidatorEmail(array('max_length' => 100)),

But no change in our SQL file. So we need to handle the database constraints by ourselve (which is not DRY). What about simpler constraints about «first_name» and «last_name» if we want to say they need to be at minimum 2 chars lenght ?

In config/doctrine/schema.yml:
    first_name: { type: string(50), notnull: true, minlength: 2 }
last_name: { type: string(50), notnull: true, minlength: 2 }
Again, this only change symfony form's validators in lib/form/doctrine/base/BaseEmployeeForm.class.php:
      'first_name' => new sfValidatorString(array('max_length' => 50, 'min_length' => 2)),
'last_name' => new sfValidatorString(array('max_length' => 50, 'min_length' => 2)),

Something else ?


That's all for this first overview. This is very good already we can use database constraints in our schema file. It seems there are other good new features with doctrine like using your own sequences but I couldn't manage to make that to work.

Another good point is it is easy to make use of Postgresql's schemas using Doctrine. But, tell me if I am wrong, I have always seen Pg schemas good at owning applications model and Doctrine does not allow (yet) users to generate a per application model, everything is under de «lib/model/doctrine» directory for the project.

Enjoy.
Par greg - Publié dans : symfony
Ecrire un commentaire - Voir les 1 commentaires - Recommander
Lundi 29 décembre 2008
Bonsoir à toutes et tous,

Tout d'abord et comme d'habitude quelques mots pour vous présenter mes excuses de ne pas avoir bloggé plus souvent ces derniers temps. Ce n'est évidemment pas le manque de choses à dire, sf 1.2 est sorti, je secoue doctrine et suis agréablement surpris, j'ai encore quelques nouvelles basheries sous le coude et surtout ... j'ai commencé il y a un peu plus d'un mois, un livre sur Vim dont je vous parlerai plus longuement un autre jour.
Le sujet qui me préoccupe aujourd'hui sort après quelques semaines, voire mois, d'avoir l'impression que quelque chose me dérange du coté de la pomme (et suite à la lecture de Linuxfr).

Pour vous situer ma petite histoire, j'ai acheté en 2006 un mac mini équipé de OSX 10.4 et il y a un an, un macbook équipé de OSX 10.5. Pour être honnête, je ne suis pas l'utilisateur principal de ces machines pour des raisons que j'exposerai un peu plus tard. J'ai, depuis le début, vu d'un très bon oeil le fait que la part des utilisateurs de systèmes autres que ceux de Redmond était en augmentation constante. Je reste convaincu que la maturité de l'informatique viendra quand les utilisateurs pourront s'adapter à toutes sortes d'interfaces. Utiliser des interfaces différentes permet de mettre en place des schémas mentaux variables de l'utilisation d'un ordinateur et cela nous permet d'apprendre à penser différement pour créer les outils de demain. C'est dans cette voie qu'Apple a lancé avec succès le remplaçant de son obsolète prédécesseur et le fameux «think different» n'a jamais été aussi vrai que ces dernières années.

Je vous passerai mes tentatives d'utilisation d'OSX,  les diverses combinaisons pomme n'ont jamais réussi à faire comprendre à X11 qu'il y avait quelque chose à coller. Pas possible de faire des glisser-déposer en utilisant exposé, il faut donc arranger ses fenêtres avant.... on est toujours obligé de manipuler les fenêtres par la barre de tître ou les coins ce qui est fastidieux .... tout cela pour vous dire que j'ai sans doute manqué le comment du pourquoi un Mac rendait le travail du développeur plus facile (surtout pour faire du dev web). Je veux bien mettre ça sur le compte de mon incapacité à comprendre comment utiliser une souris qui n'a qu'un bouton. J'ai cependant utilisé au quotidien  AfterStep, Enlightenment, fluxbox et KDE avec Kompiz et testé quelques dizaines d'autres environnements graphiques aux philosophies exotiques (dont BeOS* 5) avec plus ou moins de bonheur.

Évidemment Ubuntu et consors sont très loin d'être parfaits (Branchez un deuxième écran sur Linux et sous OSX vous verrez la différence) et OSX est beaucoup plus utilisable que son cousin propriétaire à fenêtres (installez et désinstallez une appli vous verrez la différence). J'ai plusieurs amis qui travaillent sur des images ou de la vidéo et OSX leur facilite apparemment grandement la vie. En cela OSX a encore des longueurs d'avance sur tous ses concurrents mais cette facilité, même vernie d'une présentation léchée, a un prix caché qu'il convient de considérer.

Le premier «truc qui cloche» est la différence entre paroles et faits de la part d'Apple sur les mécanismes de protection de la propriété sur tout ce qui touche à la musique. Alors que Steeve Jobs avait, en pleine sortie de Vista, fait savoir que les DRM ne marchaient pas et que si ça ne tenait qu'à eux cela n'existerait pas mais qu'ils étaient obligés de les utiliser, il s'avère que les différentes générations d'I-pode et de Mac sont de plus en plus vérouillées et vont jusqu'à refuser de lancer leur logiciel si les signatures numériques ne sont pas vérifiées.

Le deuxième truc qui cloche, c'est l'I-phone ou les développeurs sont obligés de céder leur travail à Apple pour voir leur application installable sur votre téléphone. La firme se réserve le droit d'évincer en ligne les logiciels indésirables de votre terminal comprenez les logiciels dont apple aura sa propre version ou nuira à la marque. Avait on déjà vu un comportement aussi intrusif dans l'informatique personnelle ?

Le troisième truc qui cloche ce sont les petites différences entre OSX 10.4 et 10.5 qui ne sont pas sans rappeler les choix de Microsoft concernant Vista : une simplification (encore ?) de l'interface dans le but bien légitime de nous aider, nous pauvres utilisateurs d'ordinateurs. Dans un discours ambigu, le mot «simplification» rime souvent avec «faire comme untel  veut qu'on fasse». Ainsi de plus en plus de mécanismes nous «aident» à utiliser l'ordinateur toujours de la même façon pour tout le monde. La face cachée de cela est que ça rend la conception des système de blocage plus simple. Cela pourrait paraître tiré par les cheveux si on ne savait pas que les nouveaux mac book sont étonnemment équipés d'une puce de «contrôle des contenus».

À l'heure ou je vois fleurir des notes de blogs sur «N'est il pas plus important d'utiliser des contenus libres que des logiciels libres» je m'inquiète (encore une fois) qu'on puisse commencer à transiger sur la liberté de l'information vu la place croissante notre identité numérique dans la vie de tous les jours. L'orientation que prend le deuxième acteur le plus important de l'informatique personnelle ne fait que renforcer mes craintes. Il ne faut pas placer la charrue avant les beufs, les contenus libres et les informations personnelles ne le resteront qu'à partir du moment ou l'on utilise des logiciels libres.

Microsoft après bien des victoires pour imposer son système d'exploitation au monde entier a perdu la bataille d'internet ou seuls des Internet Explorer auraient été capables d'afficher des sites faits avec Frontpage et Internet Commerce (tout cela ne fonctionnant que sous Windows évidemment propulsé par IIS). Apple est en train de gagner celle de la diffusion de contenus numériques, les chaines Hi-Fi sont pourvues de prises propriétaires I-Pod, I-Tune supporte les CD «protégés» en refusant l'importation dans votre collection et tout le monde est d'accord sauf peut être vous ... qui acceptez implicitement de voir l'ordinateur que vous avez acheté lancer à votre insu des programme pour espionner et controller l'utilisation que vous en faites mais quand il s'agit de faire avaler un suppositoire à quelqu'un on s'arrange pour le rendre joli et sucré.

En retombant dans un panier numérique qui nous ramène sans cesse au tiroir-caisse pour utiliser légitimement nos contenus, c'est à dire ceux que nous avons créé ou acheté, nous sommes arrivés aujourd'hui loin du «think different» d'un système qui prétendait amener une autre approche de l'utilisation des ordinateurs. Encore plus loin de la publicité ou Apple comparait IBM a Big Brother et sa pensée unique. En fait avec IBM et Microsoft, nous connaissons déjà cette prison du «don't think at all», peut être celle d'apple est elle plus sexy, plus agréable.

* Utilisateurs de BeOS vous serez peut être intéressés par Haiku qui bien qu'encore instable est un OS libre extrèmement prometteur.
Par greg
Ecrire un commentaire - Voir les 1 commentaires - Recommander
 
Créer un blog sur over-blog.com - Contact - C.G.U. - Rémunération en droits d'auteur - Signaler un abus - Articles les plus commentés