Et puis il y a quelques temps (2-3 ans), j'ai du travailler chez un client avec Eclipse + Plugin PHP (que je connaissais en Java mais qui ne m'attirait pas à l'époque pour PHP au vu du peu de fonctionnalités que je pensais disponible pour cette plateforme).
Ce type d'outils généère un bloc de commentaire au dessus d'une fonction ou méthode quand on en créé une (après le passage à la ligne par l'appui sur la touche entrée).
J'ai vu qu'il rajoutait des annotations ou doclet :

/**
 * ...
 * 
 * @return unknown
 */

Je me suis dit que j'allais alors remplacer unknown par le type retourné quand il s'agissait d'un objet, par exemple :

/**
 * ...
 * 
 * @return Sms
 */

(en ce temps là, j'avais encore le temps de perdre mon temps à faire des choses d'apparences inutiles dans le code...).
Jusque là, rien de transcendant. Et puis dans un autre fichier, j'ai utilisé ma méthode nouvellement créé, et là, surprise ! Eclipse me propose une autocomplétion avec la liste de toutes les méthodes de la classe Sms ! Cool !
Je me suis dit alors que j'allais essayer de systématiquement mettre les @return, et que ca m'aiderait à aller plus vite (plutôt que de chercher le nom des méthodes dispos en switchant entre les fichiers).

Puis je remarque aussi qu'il me met des @param au-dessus des méthodes / fonctions, pour décrire les paramètres de mes fonctions.

/**
 * ...
 * 
 * @param unknown $sms
 * @param unknown $xmlelement
 *
 * ...
 */

Je décide alors d'essayer de mettre des types, par exemple :

/**
 * ...
 * 
 * @param Sms $sms le sms à envoyer
 * @param SimpleXMLElement $xmlelement le document xml
 *
 * ...
 */

Et je me rends compte qu'il m'indique ces types dans l'autocompletion, ce qui m'aide dans de nombreux cas pour savoir quoi passer à la fonction / méthode.

Par contre, j'ai souvent plein de méthodes qui ne renvoient rien, donc je ne bénéficie d'aucune complétion automatique dans ces cas là.
Je me dis alors, et si je renvoyait $this ?
Je mets alors des :

...
{
    ...
    return $this;
}

à la fin de chaque méthode qui n'est pas censée renvoyer un résultat (par exemple les setters !) et je rajoute l'annotation @return <la-classe-de-$this>.
Du coup, je peux chainer certains de mes appels :

$sms = new Sms();
$sms->setSender(...)
          ->addRecipient(...)
          ->addRecipient(...)
          ->setMessage(...)
          ->send();

Cool ! Pas mal, mon code devient plus concis et du coup, j'essaye de nommer mes méthodes pour que leur "enchainement" soit compréhensible et lisible. En plus, j'ai l'auto-complétion pour chacune des lignes grâce à mon @return !

La cerise sur le gâteau : j'utilise alors le pattern Factory (avec une méthode statique) :

    /**
      * Returns a new instance of this class
      *
      * @return Sms
      */
    public final static function getInstance()
    {
        return new self;
    }

Ce qui me permet de simplifier encore mon utilisation de mes classes :

Sms::getInstance()
    ->setSender(...)
    ->addRecipient(...)
    ->addRecipient(...)
    ->setMessage(...)
    ->send();

On pourrait même mettre tout sur une ligne ! (attention à la lisibilité).

Si je résume, grâce à Eclipse et aux annotations :

  • j'ai tendance à utiliser plutôt les structures objet pour avoir l'auto-complétion (plutôt que de multiple paramètre string)
  • je fais des return $this systématiques pour les méthodes qui ne renvoient rien
  • j'ai simplifié et rendu plus lisible les noms de mes méthodes pour qu'elles s'inscrivent harmonieusement dans un enchainement
  • j'ai typé mes paramètres de fonctions / méthodes ce qui me permet d'avoir l'auto-complétion sur les paramètres dans mes fonctions
  • je crée quasi systématiquement des factories pour éviter de passer par une variable inutile
  • ...

Une vraie révolution, à l'époque, pour moi !

Et vous, quels sont les petits trucs qui ont révolutionné votre manière de coder ?