Un petit outil simple et efficace pour vérifier que toutes les routes de votre app sont couvertes par des tests. Idéal pour éviter d'introduire de nouvelles routes sans leurs tests associés.

Toutes les infos sont disponibles ici : 👉 https://github.com/odolbeau/TestedRoutesCheckerBundle

A small, simple, and effective tool to ensure that all the routes in your app are covered by tests. Perfect to avoid introducing new routes without their associated test.

All the details are available here: 👉 https://github.com/odolbeau/TestedRoutesCheckerBundle

Qu'est-ce qu'un Data Provider ?

Un "fournisseur de données" en bon français est une fonctionnalité bien pratique de PHPUnit qui permet de lancer plusieurs fois le même test avec des données d'entrée différentes.

Voici un exemple très simple (que nous réutiliserons) permettant de tester la méthode isValid d'une classe EmailValidator :

<?php declare(strict_types=1);
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

final class EmailValidatorTest extends TestCase
{
    #[DataProvider('emailProvider')]
    #[TestDox('Ensure $email is a valid email')]
    public function testValidator(string $email)
    {
        $validator = new EmailValidator();

        $this->assertTrue($validator->isValid($email));
    }

    public static function emailProvider()
    {
        return [
            'data set 1' => ['foo@bar.com'],
            'data set 2' => ['foo@bar.fr'],
            'data set 3' => ['foo@bar.br'],
            'data set 4' => ['foo@bar.es']
        ];
    }
}

Comme vous le savez peut-être déjà, le test testValidator sera lancé pour chaque données renvoyées par la méthode statique emailProvider.

C'est super, pas besoin de réécrire plusieurs fois le même test ou bien de tester plusieurs choses dans la même méthode. 👍

Quand s'abstenir d'écrire un Data Provider ?

Il n'est pas rare, lorsque l'on découvre cette petite fonctionnalité bien utile de PHPUnit, qu'on en use et surtout, en abuse !

Voilà deux cas précis où je vous encourage fortement de vous passer de ces Data Provider. :)

Quand il n'y a qu'un seul test

Prenons le test suivant :

<?php declare(strict_types=1);
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

final class ExampleTest extends TestCase
{
    #[DataProvider('additionProvider')]
    #[TestDox('Adding $a to $b results in $expected')]
    public function testAdd(int $expected, int $a, int $b): void
    {
        $this->assertSame($expected, $a + $b);
    }

    public static function additionProvider(): iterable
    {
        yield 'data set 1' => [0, 0, 0];
    }
}

Dans la mesure où notre data provider ne renvoie qu'un seul jeu de donnée, son existence même est-elle réellement pertinente ? Probablement pas !

<?php declare(strict_types=1);
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

final class ExampleTest extends TestCase
{
    #[TestDox('Adding $a to $b results in $expected')]
    public function testAdd(): void
    {
        $this->assertSame(0, 0 + 0);
    }
}

Et voilà, c'est plus lisible non ?

"Oui, mais peut-être qu'un jour, j'aurai besoin d'ajouter d'autres cas de tests".

Peut-être. Peut-être pas. Peut-être également que ce test ne sera plus pertinent ? Ou que le cas à tester méritera son propre test ? Bref, inutile d'essayer de prévoir l'avenir au risque de tomber dans l'over-engineering : "Less is more", "Keep it simple, stupid!", "You aren't gonna need it" : Wikipedia en parle bien mieux que moi 😜.

Quand le data provider vient ajouter de la complexité à votre test de base

Reprenons notre exemple de départ et admettons que nous voulions maintenant nous assurer que des emails invalides sont bien considérés comme tels par la méthode isValid. Une approche possible est de modifier le test et son Data Provider :

<?php declare(strict_types=1);
use PHPUnit\Framework\Attributes\DataProvider;
use PHPUnit\Framework\Attributes\TestDox;
use PHPUnit\Framework\TestCase;

final class EmailValidatorTest extends TestCase
{
    #[DataProvider('emailProvider')]
    #[TestDox('Ensure $email is a valid email (or not)')]
    public function testValidator(string $email, bool $isValid)
    {
        $validator = new EmailValidator();

        if ($isValid) {
            $this->assertTrue($validator->isValid($email));
        } else {
            $this->assertFalse($validator->isValid($email));
        }
    }

    public static function emailProvider()
    {
        return [
            'data set 1' => ['foo@bar.com', true],
            'data set 2' => ['foo@bar.fr', true],
            'data set 3' => ['foo@bar.br', true],
            'data set 4' => ['foo@bar.es', true]
            'data set error 1' => ['@bar', false]
            'data set error 2' => ['foo@bar', false]
            'data set error 3' => ['foo@.gr', false]
        ];
    }
}

Cependant, cela vient ajouter de la complexité (un if) dans notre test de base. Plutôt que de gérer ce cas dans le data provider existant, il suffit de rajouter un nouveau test et un nouveau Data Provider dans notre classe :

#[DataProvider('invalidEmailProvider')]
#[TestDox('Ensure $email is not a valid email')]
public function testInvalid(string $email)
{
    $validator = new EmailValidator();

    $this->assertFalse($validator->isValid($email));
}

public static function invalidEmailProvider()
{
    return [
        'data set error 1' => ['@bar']
        'data set error 2' => ['foo@bar']
        'data set error 3' => ['foo@.gr']
    ];
}

Certes, le résultat final fait quelques lignes de plus néanmois on gagne en lisibilité et on s'assure que chaque test s'occupe d'une chose précise (voir la "Séparation des préoccupations", plus connue sous le nom de "Separation of Concerns" ou SoC en anglais).

Quelques conseils lors de l'utilisation de Data Providers

1. Toujours commencer SANS Data Provider

Plutôt que de commencer par écrire directement un Data Provider, commencez par écrire un test simple. Ne créez un Data Provider qu'une fois que le test est fonctionnel et uniquement si cela vous parait toujours pertinent.

2. Utiliser le mot clé yield

L'usage d'un générateur permettra d'éviter l'utilisation d'énormes tableaux PHP pour renvoyer vos données de test. Dans le cas d'un long data provider, ça simplifie grandement la lecture mais également l'écriture. :)

3. Nommez vos jeux de données

Ca permet aux copains de savoir précisément ce qui est testé et ça n'empêche pas de lancer uniquement le test qui nous intéresse avec phpunit --filter "testAdd@data set 3"̀.

4. Evitez au maximum les Data Provider avec trop d'arguments

C'est un constat personnel que j'ai pu faire sur de nombreux projets : plus un test a besoin d'arguments différents, moins son data provider et lui sont lisibles. Bien souvent, ce symptôme peut également être le signe d'un mauvais usage des Data Provider : un découpage en plusieurs tests distincts pourrait grandement simplifier la lecture.

Si d'aventure il vous reste tout de même des Data Providers retournant une liste d'arguments longue comme le bras avec des entiers ou des booléens dont on aura tôt fait d'oublier à quels arguments ils correspondent : n'hésitez pas à nommer les clés de votre tableau de retours avec le nom des arguments !

public static function myProvider()
{
    // Sans arguments nommés
    yield [0, 0, 0, true, 'bar'];

    // Avec les arguments nommés
    yield ['expected' => 0, 'a' => 0, 'b' => 0, 'foo' => true, 'other' => 'bar'];
}

Le résultat final

Voilà ce que ça donne si on reprend les quelques conseils ci-dessus :

public static function additionProvider(): iterable
{
    yield 'Double zero' => ['expected' => 0, 'a' => 0, 'b' => 0];
    yield 'Zero left' => ['expected' => 1, 'a' => 0, 'b' => 1];
    yield 'Zero right' => ['expected' => 1, 'a' => 1, 'b' => 0];
    yield 'No zero' => ['expected' => 3, 'a' => 1, 'b' => 1];
}

Bon, c'est sur qu'avec un exemple aussi simple, les avantages ne sont pas forcément tous évidents mais j'espère que vous aurez l'occasion de vous rendre compte de leur efficacité dans vos propres tests ! 😉

Lorsque j'arrive dans un projet qui utilise GNU Make, je suis content ! 🥰

Cependant, il est courant que j'ai besoin (ou plutôt envie) de définir mes propres targets : parfois spécifiques à mon environnement, parfois très proches d'une target existante mais avec LA variation que j'apprécie, parfois spécifiques à une problématique, ...

Ces targets n'ont souvent pas grand intérêt pour les collègues (qui ont sans doute leurs propres envies avec LA variation qu'iels apprécient), les ajouter directement dans le Makefile n'est donc pas pertinent, voire serait contreproductif: si tout le monde faisait pareil, on se retrouverait bien vite avec un fichier de plusieurs centaines de lignes et donc difficilement lisible.

Heureusement, il existe plusieurs solutions !

Définir des tâches dans son coin

Proprement, avec un Makefile.local

La première solution consiste à modifier le fichier Makefile existant pour y glisser une petite ligne toute bête mais diablement efficace :

-include Makefile.local

la ligne parle d'elle même : cela permet d'inclure un fichier Makefile.local (situé dans le même répertoire) et le - devant l'instruction permet de ne pas lever d'erreur si ce fichier n'existe pas.

Il suffit ensuite d'ajouter Makefile.local dans le .gitignore du projet, de commiter le tout et mission accomplie : toute l'équipe pourra déclarer ses propres targets dans un fichier Makefile.local sans impacter les collègues ! 🥳

Rapidement, avec un GNUmakefile

Par fois il ne sera peut-être pas possible (ou trop long) de modifier le fichier Makefile existant. Pas de panique, il existe une autre solution !

Lorsqu'elle est lancée, la commande make va vérifier l'existence des fichiers GNUmakefile, makefile et Makefile (dans cet ordre) pour trouver sa configuration.

C'est l'utilisation d'un fichier Makefile qui est officiellement recommandé dans la documentation et si on en croit github, c'est effectivement la solution la plus plébiscitée : 30k occurrences de GNUmakefile, 224k occurrences de makefile et... pas moins de 3,1 millions d'occurrences de Makefile.

Sachant ça, il est donc possible de jouer avec cette notion de priorité pour créer un fichier GNUmakefile et y ajouter la ligne suivante :

include Makefile

Même stratégie que précédemment mais cette fois inversée : on inclut le fichier Makefile existant avant de déclarer ses propres targets.

Pour ma part, j'ai ajouté GNUmakefile dans mon .gitignore global pour être sur que ce fichier ne soit pas versionné.

Bonus : un GNUmakefile prêt à l'emploi

Voici un exemple de GNUmakefile que j'utilise lorsque j'en ai besoin. Je vous laisse copier ce fichier dans un projet existant pour admirer le résultat. :)

If you're working on a fast moving project, it's easy to have hundreds of migrations living in your project.

I have a question for you: Do you really think you will have to rollback the migration Version20190503193054.php (which is in your repository since more than 1 year) one day or another?

If the answer is "yes", I'll be glad to hear your arguments on twitter. Otherwise, you may be interested by this article.

Introducing doctrine:migrations:rollup command

Even if it's not documented (yet?), doctrine provides a feature to get rid of all your useless migrations.

On paper, it's pretty simple:

1. Remove all your existing migrations
2. Generate a new migration with doctrine:migrations:dump-schema.
3. Create a commit. Push your code.
4. Deploy!
5. Run the command doctrine:migrations:rollup in production

As you may have noticed, even if it looks simple, deploying a new migration containing the whole creation of your database in production is not a good idea. The migration contains all queries needed to create your whole schema but you don't want to run them on an existing database (it will fail anyway as your database already contains those tables).

To avoid this problem, there is a simple solution. You can alter your migration manually to skip it when tables already exist in the schema. To achieve this, you can use the schema manager at the beginning of the migration.

if ($this->sm->tablesExist('member')) {
    return;
}

If the member table already exists (which is probably the case in production if you have a table named like this) the migration will be skipped.

Everything's fine, you can now deploy your migration & run the doctrine:migrations:rollup command.

How to automate the rollup command

With the process described in the previous chapter, you have to manually run the rollup command on your production. This step can easily be avoided!

In your deployment process, you probably have post deployment scripts (to automatically apply your migrations in production for example?). If it's the case, you can add those few lines to automatically launch the rollup command if relevant.

if [ 1 == `ls -1 $PATH_TO_MIGRATIONS/ | wc -l` ]; then
    php bin/console doctrine:migrations:rollup
fi

Here it is! If there is one (and only one) migration available, it means you can make a rollup automatically. Don't worry, this command won't fail (nor do anything) if you launch it several times with the same migration.

I hope this article will help you remove all these useless files living in your project. :)

Let met know on twitter if it helps or f you have any question!

As you may know, I'm pretty familiar with chef and I use it almost every day, for both professional & personal stuff. Despite that, I am quite willing to try something else and Ansible is a well known (and used!) configuration management tool. I know a lot of people who are quite pleased to use it!

Furthermore, I changed my laptop last week so it was the perfect occasion to give it a try :).

Let the journey begin!

As you will see, Ansible is really easy to use.

What's the goal?

As I said, my goal is to automatically install a laptop development. I use debian and I will only focus on it. :)

I would like:

• 2 steps maximum (bootstrap + run)
• as less manual actions as possible
• an easy to understand / maintain project

Implementation

First of all, let's start with the project tree:

.
├── bin
│   └── bootstrap
├── laptop.yml
├── Makefile
├── README.md
└── roles
    └── common
        ├── files
        │   └── ssh
        │       ├── config
        │       ├── id_rsa
        │       └── id_rsa.pub
        └── tasks
            ├── main.yml
            └── nginx.yml

There aren't a lot of files which is a good point for maintainability, right? :)

Furthermore, the installation process is very simple:

1. Clone the repository
2. Boostrap the laptop with the bin/boostrap command
3. Install the laptop with make install

As you can see, I only have 2 commands to run: it seems one of my goal is already reached! \o/

Let's explain those 2 steps.

Bootstrap

As ansible isn't installed by default on your laptop, the goal of the bootstrap is to install it. Furthermore, I don't want to deal with the ansible command line because there are several arguments to include and I'm used too make install everything; that's why I need make too. Finally, as ansible will be run by my user and not by root, I need to have some privileges, that's why I also install sudo and grant all privileges to the current user.

Here is the boostrap script:

#!/bin/bash

echo "Installing sudo, make & ansible, and allow user \"${USER}\" to run any command with sudo..."

LOCAL_USER=${USER} su -c 'apt-get install sudo make ansible && echo "${LOCAL_USER}      ALL=(ALL:ALL) NOPASSWD:ALL" > /etc/sudoers.d/${LOCAL_USER}'

Once all prerequisites are installed, we can use ansible.

Installing the laptop

As I said, I use a Makefile. It contains only one command:

.PHONY: ${TARGETS}

install:
        ansible-playbook -i '127.0.0.1,' laptop.yml --ask-vault-pass

We simply ask ansible to run the playbook named laptop.yml on 127.0.0.1. Forget the --ask-vault-pass option for now, we'll discuss it later! ;)

Playbook

As said before, we ask ansible to run a playbook. In our case, it's called laptop.yml and here is the content of this file:

---

- hosts: 127.0.0.1
  connection: local
  roles:
    - common

The only impacted host is 127.0.0.1. We use the local connection (you can use ssh to configure a remote server for instance). Then we list all roles which concern our host.

It's a very simple playbook and I won't go into details on this subject for two reasons:

• you don't need anything else to configure a personal laptop
• that's a huge subject I'm definitively not the best specialist of to talk about it :)

If you're interested in anyway, you can take a look at the official documentation.

Roles & Tasks

Our playbook mention only 1 role: common.

Let's have a look at it:

roles/common/
├── files
│   └── ssh
│       ├── config
│       ├── id_rsa
│       └── id_rsa.pub
└── tasks
    ├── main.yml
    └── nginx.yml

It contains several files related to ssh and two tasks respectively called main.yml and nginx.yml.

You will always have a main.yml task in a role as it's the default entry point. Here is an extract of this file:

---

- name: install packages
  become: true
  apt: name="{{item}}" state=present
  with_items:
    - ack-grep
    - composer
    - curl
    - make
    # ...

- name: Install slack
  apt:
    deb: https://downloads.slack-edge.com/linux_releases/slack-desktop-2.1.0-amd64.deb
    state: present
  become: true

- name: Install ssh keys
  copy:
    src: "ssh/{{ item }}"
    mode: "0644"
    dest: /home/odolbeau/.ssh/
  with_items:
    - id_rsa
    - id_rsa.pub

- name: Install ssh config
  copy:
    src: "ssh/config"
    mode: "0644"
    dest: /home/odolbeau/.ssh/

- name: Download dot files from github
  git: repo=ssh://git@github.com/odolbeau/dot-files.git dest=/home/odolbeau/dot-files

- name: Install dot files
  command: make -C /home/odolbeau/dot-files install

- name: Download VIM configuration from github
  git: repo=ssh://git@github.com/odolbeau/vim-config.git dest=/home/odolbeau/vim-config

- name: Install VIM configuration
  command: make -C /home/odolbeau/vim-config install

- include: nginx.yml

There are several instructions in this file. As you may have noticed, everything is in yaml and clearly understandable.

Let's explain some of this instructions:

- name: install packages
  become: true
  apt: name="{{ item }}" state=present
  with_items:
    - ack-grep
    - composer
    - curl
    - make
    # ...

Most of the ansible instructions speak for themselves!

In this case, we create a task which will use the apt module to install a package. This task will be run with several items listed under with_items key.

The become: true option is used to run this task as root (cause the default value for become_user is root).

- name: Install slack
  apt:
    deb: https://downloads.slack-edge.com/linux_releases/slack-desktop-2.1.0-amd64.deb
    state: present
  become: true

In this case, we still use the apt module to install a remote package. Notice that you can use an inline syntax like in the first example with apt: deb="..." or the extended syntax like here.

- name: Install ssh config
  copy:
    src: "ssh/config"
    mode: "0644"
    dest: /home/odolbeau/.ssh/

Again, a very easy to understand task! I simply want to copy files coming from my roles (placed under my_role/files/) on my laptop. Easy! \o/

- name: Download dot files from github
  git: repo=ssh://git@github.com/odolbeau/dot-files.git dest=/home/odolbeau/dot-files

- name: Install dot files
  command: make -C /home/odolbeau/dot-files install

Those 2 tasks are used to install my dot-files. The first one uses git to download the repository and the second executes a make install inside the correct folder.

I won't list all modules I use though. There are plenty of them and their documentation is very clear! Don't forget to have a look at existing modules before running a command by yourself. :)

That's it!

You know everything you need to start to use ansible by yourself for a single host!

Bonus

Ask the user to do something for you

Let's confess: sometimes, it's hard / painful / time-consuming / impossible to do everything with a configuration management.

For instance, in my case, I need to install a VPN client and to create a tunnel in order to download some private projects.

Once the VPN is installed, here is what I use:

- command: ping -c 1 "a.private.url"
  register: vpn_connected
  ignore_errors: True

- pause:
    prompt: "Make sure to run the VPN in order to continue the installation. [Press any key once done]"
  when: vpn_connected|failed

I try to ping a private URL. I register the result of this command inside the vpn_connected var.

Then I use the pause module. If the tunnel isn't running, I simply ask the user to launch it, otherwise, it keeps going!

Of course, the goal is not to use this trick every time: if your users have to do everything manually, you're not using a configuration management tool correctly! Use this only when you really can't configure something automatically.

Deal with sensitive data

As previously explained, I use ansible to install my private ssh keys. Even if all my private keys are protected by a passphrase, I don't want to version them without encryption!

In my case, I use a private repository to store my ansible configuration. In this situation, it's not really necessary to encrypt your keys but as you will see, it's very easy to do! :)

Of course encrypt keys / passwords / files is a common use case and Ansible propose a very powerful solution to deal with it: Vault.

It's shipped with the ansible package and it's easy to use! I mean, really easy!

If you want to encrypt your ssh keys:

# Copy files into your role
cp ~/.ssh/id_rsa ~/.ssh/id_rsa.pub my_role/files/
# Encrypt them!
ansible-vault crypt my_role/files/id_rsa my_role/files/id_rsa.pub
New Vault password:
Confirm New Vault password:
Encryption successful

And that's it! Your files are now encrypted —congrats by the way! :)

As soon as you have encrypted file in a role, you'll have to add the --ask-vault-pass option when running the ansible-playbook command.

Conclusion

I hope I convinced you: it's pretty convenient to write an ansible playbook to install your laptop! In case you change it, you will gain a lot of time running 2 commands instead of installing everything manually! :)

Ansible is easy to use which make it a good choice to fulfill this need, but there are a lot of other configuration management tools out there, so don't hesitate to take a look at them! :)

For those who don't know it, I made a presentation of the ELK stack at the PHP Forum in Paris (in French). During this talk, I mainly talked about our (BlaBlaCar) technical logs. I also mentioned that we use ELK to make some marketing dashboards too (signups by country, payments and so on.) even if I said thaht I don't consider ELK as the best tool to do this.

Last week Claude Duvergier (@C_Duv) asked me on twitter which tool I would recommend instead of ELK. This make me think that in fact, ELK is not a bad choice, even if some others tools exist.

Disclaimer: I'm definitely not aware of all existing tools to make marketing dashboards. I will talk only about solutions I already used. Sorry if I miss something important. This article is more my personal feedback regarding some tools we use than a real comparatif.

Tools

ELK

Let me start by the one I probably know the most. ELK is very easy to setup and to use. You just have to send all important events to logstash or anything else (in our case, we send it to a RabbitMQ broker) and store them in ElasticSearch. Kibana will then help you to display all this events.

By design, all elasticsearch queries are made on the fly. ElasticSearch is "just" a data store and don't aggregate anything. You're able to update your queries when you want, filter results, etc directly in Kibana which is really appreciable. The drawback is the time needed to render some graphs for a long period.

Another point to consider with ELK is the storage needed for all your data. It can be quite huge depending on what you choose to store and on your retention policy.

Pros:

• Very easy to setup and to install
• Kibana is very easy to use (I didn't try the latest version with aggregations support but I'm sure it's even better)

Cons:

• Rendering time depends on the interval size
• Storage space needed (sometimes)

NewRelic

For those who don't know it, NewRelic is an Application Performance Management (APM). I won't talk a lot about it because even if you can make some graphs based on pages frequentation, it's definitely not the solution to our problem.

I choose to put it in this list only because we use some New Relic dashboards for technical needs (to check registrations & payments after a deployment for example) but it can looks like a marketing dashboard.

Pros:

• Easy to make some basic dashboards (once you already installed it)

Cons:

• Non free
• Very basic
• Can only track pages frequentation
• Not possible to change time aggregation interval

InfluxDB

Recently introduced at BlaBlaCar, I am fallen in love with this time series database. For now, we use it for code instrumentation purpose and we only have technical dashboards (and a bunch of issues with collected data. :P). The latest stable release of InfluxDB is the 0.8.5 and the cluster support is experimental. Despite all of this, it works well. :) It's not the goal here so I will not talk about the design of InfluxDB. You are strongly enouraged to take a look at it.

Like ELK, you need to send events with all relevant informations you need. This time however, you shouldn't query the created serie. You have to create some continuous queries in order to split your data.

For example in our case, we send an event for each http queries. This event contains the called route and we have a continuous query which create new series per route and calculate the average response time and memory usage with an aggregation of 1 minute. Another continuous query make the same, every hour.

To create dashboards with data from InfluxDB, we use grafana, a kibana clone which supports InfluxDB, Graphite and OpenTSDB. With this system, we always query the same series. It's really fast, even if you display a lot of series on a large period.

Pros:

• Really fast to display
• Can store all kinds of events (even system events for example).
• Grafana is as simple as Kibana (maybe more)

Cons:

• Harder to setup than an ELK stack
• Need to define all continuous queries to be able to use them after
• Cluster support not ready yet

Conclusion

I know that there is a lot of others solutions available to create marketing dashboards. I hesitated to talk about Hadoop / Vertica / Tableau which are also used at BlaBlaCar for data analysis. However as I don't personally use these tools, they doesn't fill my initial requirements.

Despite what I told during my talk at ForumPHP Paris, ELK IS a very good choice even more if you already use this stack to analyze your logs and if you don't need to display a long period for your marketing dashboard. If you have more time and want to use a time series database, I recommend you InfluxDB even if it's a really young software. :)

If you use another tool and think it's THE perfect solution, let me know. :)

Everything start on 7 April 2014. We gave a talk with Grégoire Pineau (aka @lyrixx) called "Making asynchronous tasks in PHP" (slides are available on speakerdeck).

During this talk we trolled about the php-amqplib created by Alavaro Videla and maintained by a lot of users.

This library is one of the 2 main ways to talk to an amqp broker. The other one is the php extension.

Anyway, the subject has come back a few days ago on twitter (conversation is in French) when Ölbaum asked us if we still recommend to not use the php-amqplib. Some tweets later, I proposed to make a small benchmark to compare these 2 ways of talking to a broker. Because trolling is good but sometimes, having some real arguments is better.

Environment

• The broker used is RabbitMQ (v3.3.5).
• I launched tests on a Mac Book Pro (2,8 GHz Intel Core i7, 16 GB 1600 MHz DDR3 with OSX 10.10).
• I used PHP 5.6.2.
• I used the last stable version for both the extension (1.4.0) and the library (2.4.1).

I chose to use Swarrot to write as few code as possible for each implementation.

The full project used for this benchmark can be found on github. Of course, feel free to contribute and complete it!

Results

And now, the results. Every tests have been launched 3 times. What you see here is the average time of these 3 launches.

Publish 1 million messages in a direct exchange

Code is here The concerned queue has been purged before each launch.

./bench publish [ext|lib] -m 1000000

With the extension

+-------------+-------------+
| Duration    |  36 seconds |
+-------------+-------------+
| Memory peak | 1.5 MiB     |
+-------------+-------------+

With the library

+-------------+-------------+
| Duration    |  46 seconds |
+-------------+-------------+
| Memory peak | 2.5 MiB     |
+-------------+-------------+

So what?

The duration difference is pretty small between the extension and the library. In both case the memory consumption is very stable (I tried with 100, 1k, 10k, 100k messages, the memory consumption is near the same).

Get 100k messages from a queue (+ ack)

Code is here.

./bench get [ext|lib] -m 1000000

With the extension

+-------------+-------------+
| Duration    |  19 seconds |
+-------------+-------------+
| Memory peak | 1.8 MiB     |
+-------------+-------------+

With the library

+-------------+-------------+
| Duration    |  43 seconds |
+-------------+-------------+
| Memory peak | 2.8 MiB     |
+-------------+-------------+

So what?

For the memory consumption, again, nothing to say. It's low and stable in both case. To consume messages, the pecl extension is more than 2 times faster than the library.

Conclusion

The extension is faster than the library. C is faster than PHP. Is it really surprising? No! It's not really pertinent to compare 2 tools which obviously make the same job but have different implementations.

The main difference is the installation. The library is VERY simple to install! You just have to add "videlalvaro/php-amqplib": "~2.4" in your composer.json and you're done. On the contrary, for the extension, you generally need to compile the rabbitmq-c (an AMQP client in C used by the php extension) which can be a bit boring.

So, if you already installed the extension or if it's not a problem for you, go for it! Otherwise, don't panic and use the library!

In both case, take a look at Swarrot (and the SwarrotBundle) to be able to change your choice if needed.

If you're not familiar with docker it's not a problem! You just need to install it and to continue reading. :)

For those who already use chef, I'm sur you write a lot of tests to check your cookbooks isn't it? :) And you know that it can take a (very) long time to run the full test suite on different VM.

But don't worry, from now on, it's over! Look at kitchen-docker.

Just add kitchen-docker in your Gemfile (or install it directly with gem install kitchen-docker) and you can now start to use docker instead of Vagrant. \o/ Just replace you're current driver in .kitchen.yml:

driver:
  name: docker

If you use docker on a Mac (with boot2docker) or inside another machine, you also need to change the socket used by the docker daemon :

platforms:
- name: ubuntu-12.04
  driver_config:
    socket: tcp://docker.example.com:4242

And that's all, you can now launch kitchen test and see the result. :)

On some cookbooks used at BlaBlaCar, running the full test suite is near 60% quicker than before.

Of course, it's not the perfect solution and there is some drawbacks. For example :

• the cron service is not automatically launched
• on my local environment (mac), when chef change the DNS used in your docker, some tests fails.
• some of our tests need a VM with more than 1 disk. Not possible with docker.

Apart from this problems, we save time everyday. \o/

Monolog

I'm sure you already know Monolog, the (almost) perfect logging library for PHP. :)

I strongly suggest you to read the core concepts of Monolog if you're not familiar with channels, handlers and processors. In 2 words, channel is the name of the logger, handlers are its outputs and processors are here to add extra information in your logs.

As we will see at the end of this article, you can make really interesting filters with your channels and the extra data added by your processors.

Gelf

Gelf means Graylog Extended Log Format. This new format has been created by Graylog to avoid all syslog inconvenients like the length limit and the lack of data types and compression.

Gelf messages can be sent by UDP (fortunately !) and of course, the awesome Monolog provides a GelfHandler.

Here is an example of a gelf message (can be found in the specs) :

{
  "version": "1.1",
  "host": "example.org",
  "short_message": "A short message that helps you identify what is going on",
  "full_message": "Backtrace here\n\nmore stuff",
  "timestamp": 1385053862.3072,
  "level": 1,
  "_user_id": 9001,
  "_some_info": "foo",
  "_some_env_var": "bar"
}

As described in the specs, some information are mandatory (but don't worry about it, just let Monolog deal with it) and you can add as many information as you wish.

Here is a small example of a custom handler to log gelf messages in logstash:

#config_dev.yml
monolog:
    ...
    handlers:
        my_logstash_handler:
            type: gelf
            publisher:
                hostname: %logstash_host%
                port: %logstash_port%
            formatter: monolog.formatter.gelf_message
            level: INFO

ELK

ELK is an acronym for ElasticSearch / Logstash / Kibana.

ElasticSearch

ElasticSearch is a very powerful distributed search engine which provides a RESTful API. In the ELK stack, ElasticSearch is the storage backend. All our logs will be stored insite an index.

Logstash

Logstash has been created to manage logs. It collects, parses and stores them. There is a lot of existing inputs (41), filters (50) and outputs (55). For example, look at this configuration file :

input {
    gelf {
        codec => "json"
    }
}

output {
    elasticsearch {
        hosts => "elasticsearch:9200"
    }
}

We have configured a single input which is gelf. As we saw it, by default, gelf logs are sent through UDP on port 12201 and of course, logstash knows it.

There is no filter in this configuraton as we don't really need it for this example. By the way, the gelf message will be directly sent to ElasticSearch.

And finally, there is an elasticsearch_http output. So, logstash will call the ElasticSearch API to insert logs into an index, generated per day.

You can take a look at the full documentation for the gelf input and the elasticsearch_http output to have more information.

Kibana

Kibana is a very powerful tool to see and interact with your data. It's very easy to use and you can create a lot of dashboards to visualize all your logs. Take a look at the project homepage to see some examples.

Tips

Create dashboards for everything !

Is there a particular error in your production environment ? Create a dashboard just for it ! You will have all available information in a single place, it will be easier to aggregate information and understand when the error occurred.

Context is your friend bro !

Of course, you all know PSR-3, which defined a standard PSR\Log\LoggerInterface (used by Monolog obviously). But did you read the "Context" section ? Did you notice that all methods defined in the interface take a $context array as second argument ? Do you use it ? No ? You should !

This context is the best way to provide more information with your log. You can easily add all needed information to know WHEN an error (for example) occurred. And once you send all this context to the ELK stack, you can easily filter your logs according to the context. Does this error occur every time with the same user ? Is it only with this particular entity ? Anyway, just add context and you will be able to group your logs according to it. :)

Cache warmer? What is this?

A cache warmer is just a class that writes in a file to store data. Really simple.

Look into you're app/cache directory. Here is an example of what you can find:

• Global configuration
• Translations
• Assetic configuration
• Doctrine proxies classes
• Twig compiled templates
• ...

Lot of things, created by cache warmers.

How to use cache warmer?

Juste create a file that extend the CacheWarmerInterface provided by the HttpKernel Component.

<?php

use Symfony\Component\HttpKernel\CacheWarmer\CacheWarmerInterface;

class MyCustomeCacheWarmer implements CacheWarmerInterface
{
    public function warmUp($cacheDir)
    {
        // Create a file here
        // Write in it
    }

    public function isOptional()
    {
        // By default, all CacheWarmer are called by the `app/console cache:warmup` command.
        // But you can specify the `--no-optional-warmers` to skip non optional ones.
        return false;
    }
}

For the implementation, you can take a look at the TemplatePathsCacheWarmer for example.

Of course, you have to declare your CacheWarmer as a service. Do not forget to tag it with kernel.cache_warmer:

<service id="my_custom.cache_warmer" class="path/to/MyCustomCacheWarmer">
    <tag name="kernel.cache_warmer" />
</service>

Now, if you run the command app/console cache:warmup (or app/console cache:clear without the --no-warmup option) your cache file should be created. (Search it in the app/cache/ folder).

To use your cached data, it's very simple. Look at TemplateLocator.

The TemplateLocator simply require the cached file and store the result into a var. To do the same thing, simply store a return statement in your file. For example, the app/cache/dev/templates.php file looks like this:

<?php return array (
    'template_name' => 'path/to/template',
    // ...
),

You're done. You can now use your custom CacheWarmer in your application. :)

Wait! What? You already write this before! Oo

Yes I do! But in french! And it seems it was not very clear... So let me explain virtuals forms again and this time... in english!

We have 2 entities. A Company and a Customer :

<?php

namespace ...;

class Company
{
    private $name;
    private $website;

    private $address;
    private $zipcode;
    private $city;
    private $country;

    // Some nice getters / setters here.
}

<?php

namespace ...;

class Customer
{
    private $firstName;
    private $lastName;

    private $address;
    private $zipcode;
    private $city;
    private $country;

    // Some nice getters / setters here.
}

Like you can see, both of our entities have these fields: address, zipcode, city, country.

Now, we want to build 2 forms. One for create/update a Company and the second to create/update a Customer.

Of course, we have only two entities which have to contains some location informations... for now! Maybe later, some entities will have this fields. So, we have to find a solution to not duplicate our code!

First, we create very simple CompanyType and CustomerType:

<?php

namespace ...;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class CompanyType extends AbstractType
{
    public function buildForm(FormBuilder $builder, array $options)
    {
        $builder
            ->add('name', 'text')
            ->add('website', 'text')
        ;
    }

    public function getDefaultOptions(array $options)
    {
        return array(
            'data_class' => '...\Company',
        );
    }

    public function getName()
    {
        return 'company';
    }
}

<?php

namespace ...;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class CustomerType extends AbstractType
{
    public function buildForm(FormBuilder $builder, array $options)
    {
        $builder
            ->add('firstName', 'text')
            ->add('lastName', 'text')
        ;
    }

    public function getDefaultOptions(array $options)
    {
        return array(
            'data_class' => '...\Customer',
        );
    }

    public function getName()
    {
        return 'customer';
    }
}

Definitely nothing complicated here.

Now, we have to deal with our four duplicated fields... Here is a (simple) location FormType:

<?php

namespace ...;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class LocationType extends AbstractType
{
    public function buildForm(FormBuilder $builder, array $options)
    {
        $builder
            ->add('address', 'textarea')
            ->add('zipcode', 'string')
            ->add('city', 'string')
            ->add('country', 'text')
        ;
    }

    public function getDefaultOptions(array $options)
    {
        return array(
        );
    }

    public function getName()
    {
        return 'location';
    }
}

We can't specify a data_class option in this FormType because, we don't have a Location Entity.
We don't have a location field in our entity so we can't directly link our LocationType.
Of course, we absolutely want to have a dedicated FormType to deal with location (remember, DRY!)

There is a solution!

We can set the option 'virtual' => true in the getDefaultOptions method of our LocationType and directly start use it in our 2 first types.

Look at the result:

<?php
// CompanyType

public function buildForm(FormBuilder $builder, array $options)
{
    $builder->add('foo', new LocationType());
}

<?php
// CustomerType

public function buildForm(FormBuilder $builder, array $options)
{
    $builder->add('bar', new LocationType());
}

With the virtual option set to false (default behavior), the Form Component expect a Foo (or Bar) object or array which contains our four location fields. Of course, we don't have this object/array in our entities and we don't want it!

With the virtual option set to true, the Form Component skip our Foo (or Bar) object or array. So, it directly access to our 4 location fields which are in the parent entity!

(One more time, thank to Alexandre Salomé for the tips)

J'ai été amené, il y a quelques jours, à utiliser l'attribut virtual du composant Form de symfony2. Le besoin était on ne peut plus simple: Créer un FormType adapté à nos besoins pour afficher un formulaire d'adresse. Ce dernier devant bien entendu être utilisé au sein de plusieurs entités disposant déjà des propriétés à éditer (address, city, zipcode, ...) et de leur getter / setters associés.
Partant de ce constat, Alexandre Salomé m'a proposé de créer un FormType "virtual"! Lorsque cet attribut est passé à true, le FormType créé utilisera les propriétés de l'objet parent!
Mais un exemple concret sera sans aucun doute bien plus parlant!

Nous avons donc une entité contenant entres autres, différents champs d'adresse:

<?php

namespace ...;

class Company
{
    private $name;
    private $address;
    private $city;

    public function getName()
    {
        return $this->name;
    }
    public function setName($name)
    {
        $this->name = $name;
    }

    public function getAddress()
    {
        return $this->address;
    }
    public function setAddress($address)
    {
        $this->address = $address;
    }

    public function getCity()
    {
        return $this->city;
    }
    public function setCity($city)
    {
        $this->city = $city;
    }
}

On se contentera ici de trois propriétés seulement (dont une qui ne nous sera pas utile pour notre FormType).

Passons à notre FormType:

<?php

namespace ...;

use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\FormBuilder;

class LocalisationType extends AbstractType
{
    public function buildForm(FormBuilder $builder, array $options)
    {
        $builder
            ->add('address', 'textarea')
            ->add('city', 'text')
        ;
    }

    public function getDefaultOptions(array $options)
    {
        return array(
            'virtual' => true
        );
    }

    public function getName()
    {
        return 'localisation';
    }
}

Notez l'utilisation de l'option "virtual".
Lors du bind de votre formulaire, notre FormType étant virtuel, ce sont les propriétés de notre objet parent (ici Company) qui seront mis à jour par le PropertyPath.

Bien entendu, il s'agit d'un FormType extrèmement basique! Vous souhaiterez prabablement ajouter quelques champs supplémentaires...

Dernière chose, n'héitez pas à passer les noms des champs qui composent votre adresse en option au FormType Localisation de manière à être plus souple.

Et histoire de jeter un petit coup d'oeil sur cet outil magnifique, autant le faire dans les meilleurs conditions. Pour ça, merci twitter et son bootstrap, qui utilise lui aussi Less (avec Preboot.less pour être plus précis).

Première chose à faire, installer less et configurer Assetic dans votre projet sf2. Pour ce faire, vous pouvez suivre l'excellent tuto de Bertrand Zuchuat (qui s'adresse avant tout aux possesseurs de Mac, mais vous devriez pouvoir le suivre sans trop d'adaptations quelque soit votre OS).

Une fois fait, il ne vous reste plus qu'à utiliser le bootstrap twitter.

Ce que devrait être rapide puisque phiamo et hidenorigoto ont déjà fait tout le travail pour vous avec le MopaBootstrapBundle.

Il ne vous reste donc qu'à installer ce bundle en suivant les instructions d'installation et vous pourrez ainsi tirer pleinement profit du bootstrap twitter (y compris dans vos formulaires puisque le style par défaut a été revu et travaillé pour l'occasion!)

J'ai récemment partagé sur twitter une liste de flux rss de blogs bds, connus ou moins connus et majoritairement en français (avec quelques exceptions tout de même). Cette liste est ici!

Vous pouvez directement vous y abonner grâce au flux ATOM (si celle-ci vous semble parfaite! :P) ou récupérer le fichier OPML contenant la liste des flux contenus dans cette liste! :) Ce dernier vous permettra de supprimer certains flux rss si ceux-ci ne vous intéressent pas! :)

Quelques-uns des 18 flux actuellement présents dans la liste:

• La Bande Pas Dessinée (grand classique! :))
• Les réflexions inutiles de Boutanox (des personnages... attachants! ^^)
• PirateSourcil (certaines bds ne plairont pas à tout le monde! :P)
• L'actu en patates (le nom résume parfaitement l'esprit de ces courtes BDs! :))
• Saturday Morning Breakfast Cereal (ainsi que la version française Les Céréales du Dimanche Matin)
• xkcd (les geeks connaissent surement! :))
• Hmm... (petite BD sans prétention faite par un geek! :))
• ...

Bien entendu, si vous connaissez d'autres blogs BDs dans le genre de ceux réunis dans cette liste, n'hésitez pas à m'en faire part dans les commentaires! :D

Si vous l'utilisez depuis un certain temps, cet article ne vous apprendra probablement rien (désolé! :P). Dans le cas contraire, vous devriez être heureux (en tout cas, moi, je l'étais! :D)

Il y a de ça quelques semaines, je devait tester un service symfony2 permettant de vérifier les droits d'un utilisateur sur une entité précise pour une action donnée. Inutile de préciser que l'éventail des possibilités était large! :D

Si comme moi, une subite envie de fuire vous prends à l'idée de devoir écrire tous ces tests à la main, restez! Et admirez:

SANS les datas providers:

<?php
class MonTestCase extends WebTestCase
{
    public function testRightsForCreateBusinessWithAdmin() { ... }
    public function testRightsForUpdateBusinessWithAdmin() { ... }
    public function testRightsForDeleteBusinessWithAdmin() { ... }
}

Nous sommes ici obligés d'écrire chacun de nos tests un par un...

AVEC les datas providers:

<?php
class MonTestCase extends WebTestCase
{
    public static function providerRights()
    {
        return array(
            array('create', 'business', 'admin'),
            array('update', 'business', 'admin'),
            array('delete', 'business', 'admin'),
        );
    }

    /**
    * @dataProvider providerRights
    */
    public function testRightsOK($action, $entity, $role) { ... }
}

Cette fois, LE test (oui, il n'y en a plus qu'un! \o/) attends certains paramètres qui lui sont fournis par le data provider déclaré juste au dessus. Ce comportement est spécifié à PHPUnit via l'utilisation d'une annotation toute simple.

De cette manière, le même test sera lancé pour chacune des données renvoyées par notre data provider! :)

Fantastique non?

Moins de code, moins de bugs, moins de maintenance, plus de lisibilité. Bref, que des avantages! :D Si vous voulez plus d'informations sur les data providers, n'hésitez pas à consulter l'excellente documentation de PHUnit ici!

(Et encore une fois, merci @futurecat! :))

Ces nouveaux attributs vous permettent d'avoir une validation côté client. Votre formulaire ne sera donc pas envoyé si des erreurs sont détectées par le navigateur. Difficile de tester vos messages d'erreurs dans ces conditions!

Heureusement, ces nouveaux attributs ont un maître! Il suffit d'un seul pour les dominer tous: l'atribut novalidate de la balise form!

Avec lui, plus de validation côté client! Vous pouvez à nouveau tester vos formulaires et vos messages d'erreurs comme il se doit! (bien entendu, n'oubliez pas de l'enlever une fois vos tests terminés! \o/)

Et on remercie tous @futurecat pour cette astuce tout bête qui nous sauve la vie! (c'était ici)

Il vous suffit simplement de modifier votre fichier routing.yml de manière à préciser la nature de la clé primaire attendue dans les requirements:

annonce:
  class: sfPropelRouteCollection
  requirements: { id: \w+ }
  options:
    model: Annonce
    module: annonce
    prefix_path: annonce
    column: id
    with_wildcard_routes: true

N'oubliez pas de changer le champ soumis à ce prérequis si celui-ci ne s'appelle pas "id" comme dans l'exemple! :)

En espérant que ce snippet puisse vous servir! ;)

Au cours de la réalisation de mon mémoire de recherche sur les solutions e-learning dans les organisations, j'ai eu la chance d'interviewer Damien DJAOUTI, Doctorant en Informatique, au sein des laboratoires IRIT et LARA de l’Université de Toulouse (31).

Développeur et concepteur de jeux éducatifs et de casual games en parallèle à ses travaux de recherche, il travaille actuellement sur les méthodologies de conception de Serious Games. A la croisée entre ses recherches académiques et ses réalisations professionnelles, il dispense également des cours et formations sur le multimédia et les jeux vidéo.

L'objectif de cet interview était bien sur d'obtenir l'avis d'un expert concernant les serious games et leur pénétration sur le marché du e-learning.

Interview

Quels sont les atouts des serious games face aux solutions e-learning existantes?

Tout d'abord, peut-être faudrait-il préciser ce que j'entends par "serious game". En effet, nombreux sont les acteurs de ce secteur, et chacun possède sa propre définition. Pour mes collègues et moi, un serious game se définit comme "tout jeu dont la finalité première est autre que le simple divertissement". Concrètement, il s'agit d'associer au sein d'un seul logiciel, une dimension utilitaire (serious) et une dimension ludique (game).

Partant de là, les Serious Games peuvent ensuite viser plusieurs fonctions "utilitaires". Aujourd'hui nous en recensons trois :

• diffuser un message (educatif, informatif, persuasif ou subjectif),
• prodiguer un entrainement (cognitif ou physique)
• favoriser l'échange de données.

Ensuite, ces familles de Serious Games se retrouvent dans un très grand nombre de domaines d'applications (santé, education, défense, publicité, politique...).

La valeur ajouté d'un Serious Game va donc varier selon la fonction et le marché qu'il vise. Pour celui de l'éducation, une des "valeur ajoutée" que l'on mentionne souvent par rapport à des solutions d'e-learning plus "classique" repose dans l'ajout de la dimension ludique. Celle-ci peut avoir plusieurs avantages : maintien de la motivation des usagers, possibilités d'interaction plus riche, appui sur une culture vidéoludique commune...

Les solutions e-learning classiques semblent actuellement rencontrer un succès mitigé auprès des utilisateurs pour diverses raisons (manque de motivation, absence d'encadrement, etc.). De plus, les jeux vidéos en général peuvent parfois pâtir d'une mauvaise image auprès des apprenants. Par conséquent, quelles sont les clés de l'intégration des serious games dans une organisation ?

Vaste question qui relève à mon avis plutôt du "cas par cas". Les freins que l'on peut rencontrer face à l'adoption du Serious Game sont effectivement de plusieurs natures.

• Appréhension liée au jeu vidéo. Celle-ci peut être de deux sortes : une méconnaissance de l'objet qui entraine une crainte des apprenants face à un objet technologique qu'ils ne maitrisent pas. Dans l'industrie du divertissement, la vague du "Casual Game" vise justement à dépasser cette barrière culturelle en proposant des jeux plus facile d'accès, moins chronophage et traitant de thème plus en phase avec un public large. Les concepteurs de Serious Games peuvent donc s'appuyer sur cette population de jeu pour essayer de concevoir des jeux en adéquation avec les connaissances préalables des apprenants (certains découvrant par exemple le jeu vidéo par le biais du Serious Game) L'autre appréhension est liée à l'image plus ou moins négative que peut avoir le jeu vidéo dans l'inconscient collectif, image résultant de plusieurs facteurs (fossé des générations, évolution historique du jeu vidéo, scandales médiatiques...). Un des pays dans lequel la notion de "jeu vidéo" est la plus péjorative se trouve être les États-Unis. Au début des années 2000, plusieurs instances publiques américaines souhaitaient utiliser le jeu vidéo, mais ne pouvaient le faire directement sous peine de choquer l'opinion publique (Columbine et les débats autour du jeu vidéo qui en ont suivi restant encore dans les mémoires). En 2002, le terme "Serious Game", dont le concept vient des années 60, a été réactualisé pour le cas du jeu vidéo. Pour pouvoir utiliser du jeu vidéo à des fins "sérieuses" sans être trop gênée par l'image péjorative du jeu vidéo, un nouveau terme a donc été employé. Il s'agit de l'oxymore "Serious Game". Une fois cette barrière culturelle passée, lorsque le grand public aura assimilé le fait que, à l'image d'un film ou d'un livre, un jeu peut traiter de différent sujets et s'adresser à différents public, nous supposons que ne nous parlerons plus de "Serious Game", mais tout simplement de jeu vidéo.
• Manque de recul sur le Serious Game. Comme il s'agit d'un domaine relativement récent et jeune, la place de l'expérimentation est encore grande. Si cela est intéressant sur de nombreux aspects (notamment pour la recherche), pour son utilisation par des institutions publiques ou privées cela représente plutôt un frein. Un des défis des entreprises qui créent des Serious Game est donc d'arriver à convaincre leur clients de tenter l'aventure, alors qu'il existe encore peu d'études de terrain à grande échelle sur leur efficacité et valeur ajoutée. En clair, nous sommes encore dans une phase "montante" du Serious Game.
• Importance des couts. La réalisation d'un Serious Game peut s'avérer sensiblement plus onéreuse qu'une campagne de communication "classique" ou qu'un simple support de cours interactif. Il faut donc que l'organisation ait un budget à consacrer au Serious Game, et arriver à la convaincre de l'intérêt d'un tel investissement.

Les clés de l'intégration du SG dans une organisation donnée serait donc d'arriver à identifier les blocages ou appréhensions de ladite organisation pour essayer d'y apporter une réponse.

Les serious games actuels peuvent ils prétendre remplacer totalement tout autre forme de formation (e-learning ou présentielle)? Cela est-il envisageable à moyen ou long terme?

Dans la pratique, le serious game et l'elearning ne sont pas contradictoires et peuvent tout à fait aller de pair. De même, l'utilisation du serious game n'exclue pas la présence d'un enseignant ou formateur, bien au contraire. Si le discours actuel, focalisé sur le "Serious Game" pourrait laisser penser qu'il se suffit à lui-même, dans la pratique il faut le voir comme un outil supplémentaire dans la trousse du pédagogue.

Après, tout cela est modulable selon l'intention et le public visée par le concepteur d'un Serious Game. S'il y a effectivement des cas ou le Serious Game peut être envisagé comme un outil autonome (publicité notamment). Mais pour le contexte de l'éducation je pense qu'il faut vraiment le voir comme un complément aux modes de formations existants. A mes yeux, les exemples les plus intéressants de jeux vidéo pour l'éducation sont ceux utilisés en classe avec un professeur (ou en stage avec un formateur), car celui-ci est le plus à même d'assurer la qualité du savoir transmis, mais peut aussi aider à contextualiser le Serious Game, aspect fondamental pour quiconque souhaite utiliser un jeu en classe. D'ailleurs, nombre de Serious Game destiné au secteur de l'éducation, tels que Lure of the Labyrinth (http://serious.gameclassification.com/11511) et Stop Disasters! (http://serious.gameclassification.com/1334), sont fournis avec des fiches pédagogiques à destination des enseignants, qui leur proposent de nombreuses pistes d'utilisations.

Quelles sont les difficultés généralement rencontrées dans la gestion du changement de solutions e-learning?

Un des gros défis des acteurs du e-learning qui se tournent vers leSerious Game est d'arriver à mélanger efficacement la dimension ludique sans pour autant perdre leur savoir faire sur la partie sérieuse. Par exemple, pour l'éducation, les notions de suivi des apprenants, de leur évaluation et de la manière dont est validé une transmission de connaissance par l'intermédiaire du jeu font partie des gros défis de conception actuels.

N'hésitez pas à rajouter ce que vous voulez, ces questions ne sont que des pistes de réflexion.

Il ne s'agit là que de réponses "générales" et rapides qui n'engagent que moi. Si le sujet des Serious Game vous intéresse, je me permet de vous signaler qu'avec mon collègue Julian Alvarez, nous allons bientôt publier un ouvrage "Introduction au Serious Game". Après une discussion sur sa définition et un passage en revue de l'état actuel du marché (avec de nombreux exemples), nous revenons sur l'histoire du Serious Game. Le dernier chapitre sera surement susceptible de vous intéresser, car nous y avons interviewé une trentaine d'acteurs impliqués dans le Serious Game (créateurs, enseignants, formateurs, consultants...) pour qu'il nous exposent leur vision du serious game, et les avantages/inconvénients qu'ils y associent.

http://livre.fnac.com/a2843459/Julian-Alvarez-Introduction-au-Serious-game

Nouvelles parutions

Jusqu'à présent, le nombre d'articles sur mon blog reste assez restreint, principalement par manque de temps (et de motivation peut-être?). Quoi qu'il en soit, j'espère inverser la tendance et augmenter la fréquence de parution! Bien entendu, cela ne se fera pas au dépens de la qualité (mais je vous laisse les seuls juges concernant ce point!)

Les thématiques resteront les mêmes et tourneront pour la plupart autour du développement (et plus particulièrement du développement web en PHP avec le framework Symfony) mais je vous parlerais aussi de l'avancement de mon mémoire de recherche sur les solutions e-learning dans les organisations et des divers autres sujets qui attireront mon attention au fil des jours!

Ancien design du blog

Nouveau design

Comme vous vous en êtes aperçus (du moins je l'espère!) le site a subi un relooking intégral! Oui, mais pourquoi?

Les gouts et les couleurs...

... ne se discutent pas! Lassitude? Besoin de changement? Qu'importe, l'ancien design ne me convenait plus, place au nouveau!

Oui, je suis auto-entrepreneur!

Très (trop?) orienté blog, l'ancien design ne mettait visiblement pas suffisamment en avant mon statut d'auto-entrepreneur! J'espère que cette fois ce défaut a été supprimé et je vous invite d'ailleurs à me contacter via le formulaire prévu à cet effet si toutefois mon profil vous intéresse.

Le mot de la fin

Je finirai par une phrase un peu bateau sur les blogs mais cependant toujours aussi réelle: Votre avis m'intéresse!

N'hésitez surtout pas à réagir à cet article dans les commentaires! Vos avis (notamment sur le design, la nouvelle organisation du blog, etc.) seront les bienvenus!

En vous remerciant! :)

Selon Wikipedia:

Une carte heuristique (mind map en anglais), également appelée carte des idées, carte conceptuelle, schema de pensée, carte mentale, arbre à idées ou topogramme, est un diagramme qui représente lesconnexions sémantiques entre différentes idées, les liens hiérarchiques entre différents concepts intellectuels. Au contraire du schéma conceptuel (concept map en anglais)1, la carte heuristique est le plus souvent une représentation arborescente des données.

Concrètement, une carte heuristique est une représentation hiérarchique d'une idée ou d'un concept. Son organisation permet une facilité de lecture étonnante.

A titre d'exemple, voici la mind map que j'ai réalisée dans le but de définir le schéma conducteur qui me permettra de réaliser l'analyse de l'existant concernant l'intégration des solutions e-learning dans les organisations (sujet de mon mémoire de recherche).

Exemple de carte heuristique

Cette carte heuristique a été réalisée avec MindManager de Mindjet, un outil (payant mais avec période d'essai) que je ne peux que vous recommander! Très simple à utiliser, de nombreuses options sont intégrées (export vers PDF, image, flash, page web, document word, gestion des taches, etc.). Et comme vous pouvez le voir, le résultat est plutôt pas mal du tout! :)

D'autres outils sont bien entendu disponible (FreeMindou MindMeister pour ne citer qu'eux). Les cartes heuristiques sont également un excellent outil pour faciliter la gestion d'un projet ou pour réaliser un travail collaboratif. N'hésitez pas à tester! :)

En internautes avisés que vous êtes, vous avez forcément entendu parler d'HADOPI, de DADVSI, de LOPPSI (ou LOPPSI 2) ou encore des pare-feux disponibles dans Open Office.

Plus récemment, Jacques Myard affirme qu'il est nécessaire de nationaliser Internet en s'inspirant du modèle chinois (plus d'infos sur son site officiel -> Dans les médias -> Communiqués). Je vous conseille d'ailleurs de lire la réaction de Benjamin Bayard, président de FDN.

Logo du parti pirate français

Bref, Internet s'invite peu à peu dans la vie politique française, pour le meilleur mais surtout (pour le moment du moins), pour le pire. En effet, lorsqu'on entend ce qu'on entend et qu'on voit ce qu'on voit, on s'interroge! Que nos représentants ne soient pas des experts informatiques, je le conçois. Mais dans ce cas, pourquoi donner leur avis sur des sujets qu'ils ne maitrisent absolument pas avec, comme seul effet, de se discréditer au yeux d'internautes sensibles à la question? D'autant plus qu'un tel comportement de la part de nos hommes politiques ne se limite peut-être pas au domaine informatique...

J'en profite pour vous rappeler que le Parti Pirate présentera une liste en Ile-de-France lors des prochaines élections régionales (qui se dérouleront les 14 et 21 mars 2010). En faveur du "partage de la culture et des connaissances", le "projet de programme coopératif" du PP "concerne toutes les libertés fondamentales en relation avec les nouvelles technologies".

Je ne peux que vous encourager à visiter leur site officiel et notamment leur FAQ dans laquelle vous trouverez nombre d'informations concernant le parti, son but et ses objectifs.

J'ai très récemment été surpris lorsque, entouré de six étudiants en troisième année d'informatique, ces derniers m'ont avoué de pas savoir ce qu'était un SVN. Voici donc un article qui je l'espère convaincra les plus indécis d'utiliser un SVN pour tous leurs projets.

Qu'est-ce qu'un SVN?

D'abord, qu'est-ce qu'un SVN? Rien de plus simple, il s'agit d'un gestionnaire de versions. Pour être plus précis, il s'agit du système de gestion de versions qui succède à CVS. Mais fini le cours d'histoire. Concrètement, à quoi ça sert? Comment ça marche? Pourquoi je m'en sers?

A quoi ça sert?

Et bien ça sert à gérer les différentes versions des fichiers d'un projet, tout simplement! :) Cette sauvegarde permet de récupérer les anciennes versions d'un fichier, de le restaurer si ce dernier à été supprimé, de le récupérer s'il a été perdu. Bref, sur un serveur SVN, Vous aurez toutes les versions de votre projet que vous aurez envoyez.

Mais là ou l'utilisation d'une serveur SVN prend tout son intérêt, c'est dans le cadre d'un projet "collaboratif". Vous êtes plus de deux à développer un projet? L'utilisation d'un serveur SVN vous permettra de travailler sur la même version de développement, sans vous envoyer les modifications par mail, par clé USB ou par je ne sais quel autre moyen existant! :)

Comment ça marche?

Très simplement. Il vous faut un serveur SVN et un client SVN. Pour le serveur, vous pouvez bien sur l'héberger vous-même sur votre bon vieux linux. Vous pouvez également faire appel au service de tiers spécialisés dans ce domaine (ou dans d'autres). Si votre projet est libre de droits, vous avez bien entendu Sourceforge ou encore Google Code. Si ce n'est pas le cas, vous pouvez utiliser XP-Dev (gratuit et marche parfaitement) ou Assembla (période d'essai gratuite, non testé mais semble avoir de bons retours).

TortoiseSVN intégré dans l'explorateur

Je ne m'attarderai pas sur l'installation du serveur SVN, de nombreux tutos sont disponibles sur le net.

Concernant le logiciel SVN client (qui sera donc installé en local) de nombreuses solutions sont encore une fois disponibles. Certainement la plus connue d'entre elles (pour ceux qui utilisent Windows), TortoiseSVN est très complet. Une fois installé, TortoiseSVN sera directement intégré dans l'explorateur.

Une fois que tout est installé correctement, le fonctionnement est très simple. Lors de la première utilisation, vous devrez faire un Checkout, qui vous permettra de récupérer toutes les données présentes sur le SVN et de lier un dossier local au serveur SVN. Par la suite, deux commandes vont seront utiles: SVN Update et SVN Commit.

La commande SVN Update mettra à jour votre copie locale du projet avec celle du serveur SVN. Cela vous permettra de récupérer les éventuelles modifications faites par vos collaborateurs.

La commande SVN Commit vous permettra d'envoyer vos modifications sur le serveur SVN, afin que ces dernières soient accessibles par vos collaborateurs.

Pourquoi je m'en sers?

Et bien pour toutes les raisons citées précédemment. Dans le cadre d'un projet collaboratif, disposer d'un serveur SVN vous épargne tous les habituels transferts de fichier entre les différents participants et vous fait gagner un temps précieux.

Dans le cadre d'un projet personnel, l'utilisation d'un serveur SVN permet d'avoir continuellement une sauvegarde à jour de votre projet mais vous autorise également à travailler sur votre projet depuis différents PC.

Enfin, bien que ce sujet n'ai pas été abordé dans cet article, vous pourrez installer d'autres solutions sur votre serveur SVN. Ainsi l'installation de TRAC par exemple, vous permettra de gérer votre projet grâce à différents outils tels qu'un wiki, un gestionnaire de bugs, un explorateur Subversion, etc.

Voilà, ce rapide aperçu des avantages d'un serveur SVN s'achève ici. Je ne peux que vous encourager une fois de plus à utiliser un serveur SVN (si ce n'est déjà le cas) pour tous vos projets, collaboratifs ou personnels, que vous travailliez sur une ou plusieurs machines, que vous en ayez ou non envie.

Ce mémoire de recherche qui me permettra (si tout se passe bien) d'obtenir le diplôme M2IRT (Bac +5) à l'ITIN portera sur les solutions e-learning dans les organisations.

Différents jalons imposés par l'école viendront rythmer les mois à venir au cours desquels je l'espère, les solutions e-learning dans les organisations n'auront plus aucun secret pour moi. Loin d'être un simple exposé sur un sujet distribué aléatoirement, ce mémoire devra être, je cite, "une oeuvre originale et unique" au sein duquel l'auteur présentera "le résultat de ses recherches et découvertes" avant de "défendre ses conclusions et les solutions pratiques proposées".

Pour mener à bien ce projet, chaque étudiant pourra compter sur le soutien de son directeur de mémoire, qui n'est autre que la personne ayant proposé le sujet choisi.

En ce qui me concerne, j'aurais la chance de collaborer avec Margarida Romero, chercheuse et consultante en gestion du changement en formation et e-learning (que vous pouvez suivre sur Twitter. Pour ceux que l'espagnol et l'anglais ne rebutent pas, vous pouvez également visiter son blog.

Le premier livrable de ce mémoire est un document de définition du sujet de quatres pages, structuré de la manière suivante:

• Définition du sujet
• La question fondamentale
• Le contexte, l’environnement (scientifique, technique, marché…)
• Quelles seront les méthodes de recherche et de résolution des problèmes utilisées

L'heure est donc à la recherche d'informations concernant les solutions e-learning, en espérant pouvoir vous faire une présentation succincte de ces dernières dans un prochain article! :)

Pour simplifier, les alias permettent uniquement de créer un "lien symbolique" entre un dossier choisi (par exemple le dossier contenant toutes le sources de phpmyadmin) et votre serveur web. Une fois votre alias créé, il vous suffit d'appeler l'URL que vous auriez appelé si le dossier choisi se trouvait physiquement à la racine de votre serveur web. (http://localhost/phpmyadmin).

Avec les virtuals hosts, le fonctionnement est fondamentalement différent. Ici, le but est d'avoir plusieurs racines de sites web avec un seul et unique serveur apache. L'intérêt? Pouvoir gérer divers sites indépendamment les uns des autres, ce qui n'est pas le cas en utilisant les alias, puisque cette solution n'utilise qu'une seule racine.

Maintenant que vous êtes convaincu de l'intérêt des virtuals hosts (du moins je l'espère), passons à la configuration d'apache! :)

La configuration des virtuals hosts se fera dans le fichier httpd-vhosts.conf (dossier /conf/extra du répertoire d'installation d'apache). Mais avant de commencer, il faut vérfier que ce fichier est bien appelé par le fichier de configuration principal, à savoir httpd.conf (dossier /conf du répertoire d'installation d'apache).

Ouvrez donc ce fichier et vérifiez que la ligne d'include de httpd-vhosts.conf est bien décommentée:

# Virtual hosts
Include conf/extra/httpd-vhosts.conf

Maintenant, on commence les choses sérieuses en ouvrant le-dit fichier httpd-vhosts.conf.

Vous pouvez commencer par supprimer les exemples avant d'ajouter cette ligne INDISPENSABLE à votre fichier:

NameVirtualHost *:80

Ensuite, voici la configuration pour un virtual host pour le site "monSiteWeb":

<VirtualHost *:80>
    DocumentRoot "c:/racine/de/monSiteWeb/"
    ServerName local.monsiteweb.fr
    ServerAdmin webmaster@monsiteweb.fr
    ErrorLog logs/local.monsiteweb.fr-error_log
    TransferLog logs/local.monsiteweb.fr-access_log
</VirtualHost>

Quelques explications:

• DocumentRoot: Le chemin d'accès à la racine de votre projet
• ServerName: Le nom qui sera utilisé pour accéder au site. Vous pouvez mettre ce que vous souhaitez! Personnellement, j'ai pris l'habitude de mettre "local." suivi du nom du site afin d'être certain que cette URL est bien locale.
• ServerAdmin (facultatif): L'adresse mail de l'administrateur du site.
• ErrorLog (facultatif): le fichier dans lequel seront stockés les logs d'erreurs de votre site.
• TransferLog (facultatif): le fichier dans lequel seront stockés les logs d'accès de votre site.
• D'autres paramètres sont bien entendu disponibles. je vous laisse vous référer à la documentation officielle si besoin est.

Redémarrez maitenant votre serveur apache afin que les changements soient pris en compte.

Votre virtual host est maintenant fonctionnel! Dernière manipulation avant de pouvoir y accéder, mettre à jour votre fichier hosts!

Ce dernier se trouve:

• pour Windows: C:\WINDOWS\system32\drivers\etc\hosts
• pour Linux: /etc/hosts

Ajoutez la ligne suivante:

127.0.0.1     local.monsiteweb.fr

Cela signifie que toutes les requêtes adressées à local.monsiteweb.fr seront transférées au serveur 127.0.0.1, c'est à dire VOTRE serveur.

Vous devriez maintenant pouvoir tester votre configuration en vous rendant à l'adresse suivante: http://local.monsiteweb.fr

Si vous avez une erreur 404, assurez-vous que votre navigateur a bien pris en compte les modifications effectuées dans le fichier hosts. Pour cela effacer le cache et rédemarrez-le.

Une solution simple pour s'éviter une partie de ces contrôles rébarbatifs (et bien souvent faillibles): obliger l'utilisateur à sélectionner la ville qu'il souhaite dans une liste déroulante. Et la difficulté principale liée à la mise en place d'un système semblable n'est bien sur pas d'ordre technique.

En effet, la première étape consiste à trouver un référentiel complet des communes françaises. Et c'est là que les choses se compliquent. Les nomenclatures officielles semblent rares et sont généralement peu complètes.

A ce jour, le référentiel le plus complet que je suis parvenu a trouvé est celui de l'INSEE (disponible ici au format txt et mbf). Il contient la liste complète des communes, cantons, arrondissements, départements et régions de France au 1^er^ janvier 2009 (les référentiels des années précédentes sont également disponibles sur la même page). Malheureusement, ce référentiel ne contient pas les code postaux des communes.

Je me suis personnellement limité aux régions, départements et communes, jugeant les cantons et les arrondissements d'un intérêt limité. J'ai également supprimé de nombreuses informations pour ne garder que l'essentiel, c'est à dire pour les communes: le nom, le département et la région.

Voici donc le script SQL (généré par phpmyadmin) qui vous permettra de créer les trois tables (régions, départements et communes) puis de les remplir. Vous pouvez également récupérer l'archive (zip) contenant ce fichier.

Petit bonus pour celles et ceux qui utilisent Symfony, voici les 3 fichiers fixtures (pour Propel uniquement): régions, départements et communes. Vous pouvez également récupérer l'archive (zip) contenant ces trois fichiers.

Il ne vous reste plus qu'à créer vos listes déroulantes! :)

Sites spécialisés

• Open Source Web Design - OSWD: Certainement l'un des plus connus, vous y trouverez plus de 2000 templates gratuits. La qualité de la plupart d'entre eux laisse à désirer mais vous devrez néanmoins pouvoir y trouver quelques designs d'excellente qualité. Attention, le site propose également quelques designs payants et ne permet plus l'ajout de nouveaux designs depuis 2007.
• OpenWebDesign: Fork de OSWD créé en 2005 il semble prendre le pas sur son ainé. Ce sont pas moins de 3700 designs qui vous attendent (dont la plupart de ceux d'OSWD). Encore une fois la qualité des templates dépend très fortement de leurs auteurs.
• OpenDesigns: Un site de plus en plus connu et pour cause: plus de 1300 designs disponibles et généralement de qualité bien meilleure que sur OSWD et OpenWebDesign. L'outil de recherche laisse malheureusement à désirer et vous oblige à parcourir les nombreuses pages du site pour trouver votre bonheur.
• Open Source Web Templates - OSWT: Un peu plus de 250 designs de qualité hétérogène pour ce site peu intuitif. Open Source Web Templates a au moins le mérite d'intégrer un moteur de recherche plus ou moins fonctionnel ce qui n'est pas tout le temps le cas de ses concurrents.
• Solucija: Très peu connu et contenant un nombre restreints de designs gratuits (à peine plus de 30), il mérite cependant sa place dans cette liste en raison de la qualité des designs proposés. Ces derniers sont en effet très bien réalisés et facilement modifiables.

Solutions alternatives

Certains graphistes / web agency n'hésitent pas à mettre à la disposition de tous quelques designs d'excellente qualité sur leur site (généralement pour promouvoir leurs designs payants). Citons par exemple:

• Andreas Viklund
• FullaHead
• Arcsin
• CssTemplateHeaven
• Six shooter media
• ...

N'hésitez pas à me signaler d'autres sites! :)

Et bien en voici quelques unes pour symfony! :)

• Directory Structure and CLI par Andréia Bohner Un rappel de la structure par défaut des répertoires dans Symfony ainsi qu'un brève description de la plupart des commandes CLI existantes. A consulter impérativement et à garder sous la main (pour les commandes)! Télécharger le PDF (en) - Télécharger le PDF (fr)

• View par Andréia Bohner Récapitulatif des différents éléments liés aux vues. Localisations, templates, variables, configuration, helpers, etc. Peu intéressant. Télécharger le PDF (en)

• View: Partials, Components, Slots and Component Slots par Andréia Bohner Résumé plutôt complet permettant d'avoir un aperçu des possibilités / rôles des partials, components, slots et component-slots. Très utile à titre de rappel. Télécharger le PDF (en)

• Form Helpers par Andréia Bohner Cheat sheet bien réalisée qui reprend l'ensemble des Form Helpers avec pour certain une brève description. Complet et clair. Permet d'avoir la liste des helpers existants lors de la construction d'un formulaire. Télécharger le PDF (en)

• Javascript and Ajax Helpers par Andréia Bohner Même objectif que précédemment mais cette fois-ci avec les helpers Javascript/Ajax. Description détaillée pour les principaux helpers, listing pour les autres. Utile lors de la construction de formulaire. Télécharger le PDF (en)

• Server Validation par Andréia Bohner Un ensemble d'informations sur la validation et la repopulation de formulaires. Cette cheat sheet fourni une description succincte de quelque validators et explique brièvement la manière de les employer. Trop basique pour être utile. Télécharger le PDF (en)

• Model par Andréia Bohner Petite cheat-sheet dédiée au model; classes, collections, types de colonnes, un exemple de mapping simple en fin de document, bref, rien de bien excitant. Télécharger le PDF (en)

• Model: Schema par Andréia Bohner Etude complète d'un exemple de mapping propel. Très bien réalisé, complet et intéressant. Peut-être pas indispensable au quotidien, mais à (re)lire impérativement. Télécharger le PDF (en)

• Lime Unit & Functional Testing par Benjamin Meynell Récapitulatif de l'ensemble des commandes utiles lors de la réalisations de tests unitaires ou de tests fonctionnels. Idéal à titre de rappel mais pas indispensable. Télécharger le PDF (en)

• ORM par Andréia Bohner Schéma récapitulatif du rôle des différents fichiers de conf et commandes CLI liés à l'ORM (Mapping Objet-Relationnel). Extrêmement clair et par la même idéal pour bien appréhender le fonctionnement interne du framework à ce niveau. Télécharger le PDF (en)

• Criteria/Criterion/RS par Andréia Bohner Quelques exemples de Criteria/Criterions assez simplistes dans l'ensemble, encadrés par la liste des méthodes des classes Resultset et Criteria. Peu intéressant dans l'ensemble. Télécharger le PDF (en)

Liste complète des cheat-sheets disponibles sur le TRAC de symfony

MAJ: D'autres cheat-sheets disponible sur ce site.

La procédure d'installation de symfony sur une architecture WAMP ne présente aucune difficulté particulière et peux aisément se réaliser en suivant les instructions de la documentation officielle du framework symfony ou du premier chapitre de l'excellent tutoriel Jobeet.

Cependant, pour celles et ceux que l'anglais horripile ou qui préfèrent suivre des explications adaptées à leur plateforme, voici les étapes à suivre pour installer le framework symfony.

Seul prérequis avant de démarrer l'installation, assurez-vous d'avoir une version de WampServer à jour.

Première étape: Installation de PEAR

Définition de Wikipedia pour PEAR:

PEAR (pour PHP Extension and Application Repository) est une collection de bibliothèques PHP. C'est aussi une application qui permet de gérer les bibliothèques (installer ou mettre à jour une bibliothèque).

PEAR va permettre d'installer symfony (ainsi que de nombreux autres packages) grâce à une simple ligne de commande.

MAJ: La manipulation permettant d'installer PEAR dépend maintenant de votre version de WampServer (merci à LeoSquall pour la remarque!)

• Version 2.0h ou inférieure:

  Pour installer PEAR, lancez go-pear.bat situé dans le dossier bin/php/php5.x.x de votre répertoire d'installation de WampServer en utilisant l'invite de commande.

  Ce qui donne dans mon cas:

  cd C:\APPS\WampServer\bin\php\php5.2.6
  go-pear.bat

• Version 2.0i ou supérieure:

  Créez un fichier script.bat dans le dossier bin/php/php5.x.x de votre répertoire d'installation de WampServer puis copiez-y le code suivant:

  php -d phar.require_hash=0 PEAR\go-pear.phar

  Exécutez le script en double cliquant dessus ou via l'invite de commande

MAJ: Vous pouvez continuer de suivre ce tutorial, quelque soit votre version de WampServer! :)

Modification de la variable Path

Au cours de l'installation, contentez-vous d'appuyez sur Entrée à chaque nouvelle demande et de répondre par l'affirmative lorsque que le script vous demandera si vous souhaitez qu'il modifie votre fichier php.ini (Would you like to alter php.ini ?).

Maintenant que PEAR est installé, il ne reste plus qu'à s'en servir! :) Pour cela il va falloir rajouter une nouvelle variable système. Rien de plus simple: Clic droit sur le poste de travail -> Propriétés -> Onglet "Avancé" -> Variables système.

Modifiez à présent la variable Path en ajoutant simplement à la fin de la chaine l'adresse du dossier utilisé auparavant (celui dans lequel se situe le script go-pear.bat) précédé d'un point virgule. Dans mon cas: ; C:\APPS\WampServer\bin\php\php5.2.6

Fermer l'invite de commande puis ré-ouvrez la afin que les modifications soient prises en compte.

Voilà, PEAR est installé et fonctionnel!

Deuxième étape: Installation de symfony

Comme expliqué ci-dessus, PEAR va maintenant nous permettre d'installer symfony grâce à une simple ligne de commande! Ou plutôt deux! La première va permettre d'enregistrer un nouveau channel contenant une liste de packages. Une fois ce channel ajouté, il suffit d'installer le package de son choix, en l'occurrence, la dernière version stable de symfony. Voici les commandes:

pear channel-discover pear.symfony-project.com

puis

pear install symfony/symfony

A présent que symfony est installé, reste à mettre en place un minimum de configuration.

Troisième étape: Configuration

Afin de faire fonctionner symfony, il faut vérifier et éventuellement modifier votre configuration de php et d'apache.

Modification de la configuration de php

Tout d'abord, ouvrez le fichier php.ini situé dans le même dossier qu'auparavant. Si vous utilisez WampServer, une fois celui-ci démarré, vous pouvez accéder rapidement au fichier en cliquant (gauche) sur l'icône de WampServer dans la barre des taches, puis PHP -> php.ini.

Dans ce fichier, deux choses à vérifier. Rechercher memory_limit et vérifier que la valeur est supérieure ou égale à 16M (memory_limit = 16M).

Enfin, si vous utilisez une version inférieure à PHP 5.3, vérifier que les magic quotes (guillemets magiques) sont désactivés (magic_quotes_gpc = Off)

Modification de la configuration d'apache

Ouvrez maintenant le fichier httpd.conf situé dans le dossier bin/apache/apache2.x.x/conf du répertoire d'installation de WampServer ou encore une fois, accédez-y via l'icône de WampServer situé dans la barre des tâches (Apache -> httpd.conf)

Vérifiez que le module apache de rewriting, rewrite_module est bien activé (pas de # devant la ligne: LoadModule rewrite_module modules/mod_rewrite.so)

N'oubliez pas de redémarrer le serveur apache afin que les modifications soient prises en compte!

Dernière étape, nous devons permettre au serveur apache d'accéder aux images, feuilles de styles et fichier javascript fournis par symfony et utilisé notamment par l'admin generator, les pages par défaut et la barre de debug.

La solution la plus optimale est d'utiliser un alias apache (plus ou moins l'équivalent d'un lien symbolique sous unix). Cependant, cette solution dépendant notamment de votre configuration apache existante et de l'utilisation que vous faites de votre serveur (multi-sites, etc) je ne la détaillerai pas dans cet article. Vous trouverez néanmoins un nombre important d'informations dans la documentation officielle de symfony ou dans celle d'apache.

Nous allons donc nous contenter d'utiliser la seconde solution. Pour cela, commencez par créer votre projet symfony en suivant les instructions de la documentation, puis copiez/collez l'ensemble des fichiers situés dans le dossier bin/php/php5.2.6/data/symfony/web/sf du répertoire d'installation de WampServer dans le répertoire web/sf de votre projet symfony. Cette solution fonctionne parfaitement, néanmoins vous serez obligé de refaire cette manipulation pour chaque projet que vous réaliserez sur votre machine mais également à chaque nouvelle version de symfony que vous utiliserez par la suite.