Pour maintenir cette branche à jour par rapport à master, j’utilise de préférence git rebase (par rapport à git merge).

Ça donne par exemple :

$ git checkout big_change
$ git rebase master

Le problème est que si je pousse ma branche big_change sur un dépôt distant, les “rebase” deviennent dangereux. Mais si je ne pousse jamais cette branche, et que je perds le contenu de mon dépôt local, alors je perds tout mon travail sur cette branche.

Évidemment, tout développeur sérieux dispose de sauvegardes de son poste de travail, mais selon les outils il peut être fastidieux d’y accéder juste pour quelques fichiers. Et puis il y a ceux qui n’ont aucune sauvegarde (les fous !). Pourquoi ne pas utiliser Git pour ça ?

Je me suis donc créé un petit script (accessible depuis mes dépôts) qui me permet de pousser ma branche courante sur un dépôt distant (origin par convention, modifiable en ajoutant un paramètre à l’appel du script), mais de manière à identifier qu’elle n’est qu’à des fins de sauvegarde.

#!/bin/sh
set -e
CUR=`git branch | grep '\*' | awk '{print $2}'`
REM=${1:-'origin'}
git push --force ${REM} ${CUR}:backup/${USER}/${CUR}

On trouvera donc sur le dépôt distant, un groupe de branches appelées “backup”, puis un sous-groupe pour chaque développeur, dans lequel il y trouvera ses branches de sauvegardes, nommées comme ses branches locales.

Ça crée donc une convention, facile à comprendre.

Plus généralement, si il y a un ou plusieurs “/” dans le nom d’une branche, Git va traiter ça comme des portions d’arborescence de système de fichier et grouppera donc toutes les branches dans les mêmes dossiers et éventuellement sous-dossiers.

J’utilise ce système pour toutes les branches qui correspondent à des fonctionnalités, par exemple :

• features/new_login
• features/alternate_footer
• …

Ainsi dans les outils (graphiques ou en mode texte), je vois ces branches groupées, voire même de manière arborescente. Si vous ouvrez le dossier “.git” de votre dépôt, vous verrez que Git crée réellement des dossiers et sous-dossiers dans “.git/refs/heads” et “.git/refs/remotes/xyz/” et les branches y sint de vrais fichiers appelés comme la dernière partie du nom donné à la branche.

Imaginons que vous êtes candidat, que ma société s’appelle BigCorp et que je m’adresse à vous.

Postuler ou pas ?

Arroser la planète entière avec votre CV n’a que peu de chances de vous trouver un travail.

Cherchez bien à identifier le profil recherché et voir si vous pensez correspondre.

Si le profil recherché est expérimenté dans la construction de sites web de e-commerce et que vous êtes en première année d’IUT informatique de gestion, sans réelle expérience personnelle, ou bien si c’est un administrateur système qui est recherché alors que vous avez juste un peu bidouillé votre PC à la maison, ne répondez pas. Vous gagnerez du temps et surtout vous en économiserez au recruteur. Imaginez que vous soyez pris sur un malentendu ; c’est perdant-perdant.

Le mail de réponse

Si vous connaissez l’identité du destinataire, indiquez la en début de message lorsque vous vous adressez à lui/elle. Pas de “Madame, Monsieur, Mademoiselle” si vous savez que c’est Martine Durand qui est responsable de recrutement.

Indiquez à quelle offre vous répondez (et si possible comment vous l’avez trouvée), car il peut y avoir plusieurs recrutements en même temps dans l’entreprise.

Soyez attentif à la forme de votre message : politesse, orthographe, phrases courtes et bien construites, … Vous perdez de sérieux points lorsque vous laissez traîner plus d’une ou deux fautes d’orthographe dans votre message, lorsque la ponctuation est très mal (ou pas) utilisée, …

L’idéal est de coller au style de l’annonce sur le niveau de langage, le style de phrases, … Ça n’est pas simple, mais vous marquerez des points si c’est remarqué.

J’ai tendance à préférer l’expression de la motivation d’un candidat dans ce mail de réponse plutôt qu’un message presque vide et une pièce jointe “Lettre de motivation”.

Soyez original(e) si vous pensez que ça peut s’y prêter. Il n’est pas interdit de sortir du cadre des conventions classiques. Les meilleurs recrutements que j’ai fait sont souvent des personnes qui ont sur se différencier par le fond et la forme. Par contre c’est un exercice difficile car on peut aussi totalement tomber à côté de la plaque.

La “lettre de motivation”

Son but est de montrer que vous avez envie d’intégrer l’entreprise qui recrute et que vous lui apporterez ce qu’elle attend.

Ne sortez pas les phrases toutes faites, apprises à l’école. N’expliquez pas au recruteur ce qu’il sait déjà de son entreprise, surtout si c’est pour dire n’importe quoi (“Votre entreprise, leader sur son marché et son territoire” lorsque c’est une PME de 3 salariés). Trouvez d’autres moyens pour montrez que vous avez fait des recherches sur l’entreprise. Si elle dispose d’un blog, vous y trouverez des infos pertinentes pour comprendre la culture de l’entreprise, qui y travaille, …

Énumérer vos qualités risque de rapidement tomber dans les “sens des responsabilité”, “qualité relationnelle”, … qu’on attend presque toujours chez tout candidat. Indiquez plutôt ce qui peut vous démarquer au niveau de vos expériences, de votre parcours, … et qui est particulièrement adapté à l’entreprise.

Si vous y croyez, expliquez pourquoi vous pensez que n’êtes pas simplement “bon pour le poste”, mais le/la meilleur. Si vos arguments sont bons, ça ne passera pas pour de l’égocentrisme et de la vanité.

Le CV

Le CV est un piège dans lequel il est facile de tomber car les écoles nous apprennent souvent à faire des mauvais CV.

Soyez succinct ; le plus souvent 1 seule page suffit et pour ça il convient de bien choisir ce qu’on met en avant.

Tous les logiciels que vous avez utilisé, tous les micro-stages dans des entreprises qui n’ont rien à voir avec l’offre, le baby-sitting, … n’ont pas besoin de se trouver sur votre CV. Idem pour les hobbies personnels, mentionnez les s’il vous reste de la place.

Choisissez ce qui correspond particulièrement au profil du poste, quitte à mentionner que ça n’est pas tout et que seriez ravi de discuter de vos diverses expériences en annexes.

Si votre profil vous permet de postuler plusieurs offres, personnalisez un CV par poste, pour être bien ciblé.

Dans sa forme, un CV doit être sobre et très lisible. Si vous mettez une couleur ou un motif de fond, 3 polices de caractères différentes, des encadrés autour de chaque paragraphe, … vous vous y prenez mal.

Il conseillé d’annexer (directement ou avec un lien) un échantillon de vos précédentes réalisations, pourvu que ça soit adapté au poste pour lequel vous postulez. Si vous êtes développeur, indiquez ce qui est consultable en ligne (compte GitHub ou autre), un portfolio si vous êtes graphiste, …

Les pièces jointes

Format des fichiers

Il est indéniable que Microsoft Word est très répandu (bien que je doute que la plupart étudiants ait une licence valide), mais ça n’est pas non plus le standard.

J’ai le droit de ne pas vouloir payer plusieurs centaines d’Euros pour une licence entreprise de ce produit, ou bien d’utiliser un système sur lequel il n’est pas disponible. En m’imposant ce format propriétaire, vous réduisez les chances que je puisse consulter votre candidature.

Il existe cependant des formats libres, plus ouverts, et encore plus répandus.

• le texte brut : c’est assez rustique, mais la solution ultime en terme d’accessibilité. Le plus souvent, un CV n’a pas besoin de faire preuve d’une grande créativité en terme de mise en forme. Si vous êtes dans des métiers de l’image, créez des documents adaptés : animés ou statiques selon, mais qui correspondent au destinataire.
• le RTF : il permet une mise en forme plus riche, il est tout à fait standard et tous les logiciels de traitement de texte savent lire et exporter ce type de document.
• le PDF : bien que format pas totalement libre, il existe des “lecteurs de PDF” pour quasiment tous les systèmes. Il a l’avantage de permettre une mise ne forme très poussée, une bonne accessibilité s’il est bien construit, peut être imprimé sans dégradation de format, …

Nom de chaque document

Le plus souvent, lorsqu’une entreprise publie une offre, elle ne reçoit pas seulement votre candidature.

Des documents qui s’appellent “CV.doc”, “LM.doc”, “profil.doc” ou encore “modèle.doc” deviennent totalement anonymes lorsqu’ils sont sortis du contexte du mail auquel ils étaient joints. Je classe tous ces documents dans un dossier correspondant au recrutement en cours. Il m’est donc beaucoup plus utile d’avoir des fichiers du genre “John Doe – CV.pdf”, “John Doe – LM BigCorp.pdf”.

• votre nom en début permet de grouper plusieurs documents vous concernant lors d’un tri alphabétique.
• indiquez ensuite le type de document s’il y en a plusieurs.
• si votre lettre de motivation est personnalisée (fortement conseillé), indiquez le nom de l’entreprise destinataire, ça montre un effort d’adaptation.

Conclusion

Avec un minimum d’effort, c’est finalement assez facile de ne pas faire mauvaise impression lorsqu’on postule à une offre d’emploi ou de stage. Et si vous faîtes cet effort, vous serez probablement remarqué(e) et vous marquerez de précieux points lorsqu’il faudra décider de ne pas faire passer votre candidature dans la corbeille, mais à l’étape suivante de la sélection.

Mise à jour (31/11/2011) : Sur son blog, J-Mad complète judicieusement mes conseils.

J’ai pu en bénéficier quelques fois à mes débuts (trop peu à mon goût, d’ailleurs) et ça m’a beaucoup servi.

C’est pourquoi je voudrais consacrer un peu de mon temps, régulièrement (et gratuitement), pour accompagner des personnes qui souhaiterais avoir un œil extérieur sur leur code, leurs pratiques, leurs méthodes, leurs outils, …

Il ne s’agit pas de formation au sens institutionnel du terme, mais plutôt d’observation, de critique et de conseil, dégagé de tout troll (dans la mesure du plus possible).

Je propose donc de passer 30 minutes à 1h en tête-à-tête, lors de chaque réunion du PLUG, avec une personne pour une séance de pair-programming, ou de discussion technique sur un sujet, … Ça peut être sur mes technos de prédilection, mais aussi sur n’importe quel langage, framework, … ou sur des méthodes de travail car il ne s’agit pas forcément de décortiquer le détail de chaque ligne, mais pourquoi pas d’avoir un regard critique d’ensemble, …

Faites moi signe (en commentaire, par e-mail, via Twitter, …) si vous êtes intéressé. On peut faire une tentative dès la prochaine réunion du PLUG, le 4 novembre. En cas de demandes multiples, je me réserve la liberté de choisir le sujet avec lequel je me sentirai le plus à l’aise ou le plus intéressé.

Mise à jour (21/11/2011) : La première tentative est concluante (pour moi au moins), donc je propose de recommencer dès la réunion du PLUG le 2 décembre.

The Tribesports way

Recently, I’ve seen a blog post about the Tribesports API. They chose to add a new MIME type to the application and use the rendering features of Rails.

Maybe I’ve not seen all the constraints they might have, and that lead to this choice, but from my point of view, 2 things are bothering me :

1. they had to change too much things in the rendering process
2. they created the api_v1 content type but in fact it’s plain JSON

What if they wanted to render JSON or XML but for the version 1 of their API ?

Another way

With a simple protected method in the ApplicationController, it’s possible to inspect the Accept HTTP header, and extract an API version number, while letting Rails decide what is the real content type to use.

class ApplicationController < ActionController::Base

  respond_to :html, :xml, :json

  protected

  def api_version
    default_version = '1'
    pattern = /application\/vnd\.com\.example\.api\.v([\d\.]+)\+.*/
    request.env['HTTP_ACCEPT'][pattern, 1] || default_version
  end
end

In this example, by default all the action method of all controllers will respond to HTML, XML and JSON, and Rails is probably using the default HTML if nothing is specified. I can even implement a rendering for another format in the respond_to block of a action method, like format.js for Ajax requests, …

We now have a method, accessible from all controller methods (including actions) to get the desired API version nummber. If an “application/vnd”-style Accept header is found and if a version number can be extracted, then it is used. There is a fallback to the default version.

With this, you can have any test you want at the controller level on the API version, without messing with the content type.

About the default version number, some prefer the lastest (and allow clients to set a specific version), and some prefer the first version. I prefer the “latest by default” way.

NB : I’m quite sure I’ve not made this one up, but I honestly can’t remember where I’ve read this from.

During a deploy with Capistrano, I had some errors like this :

You have modified your Gemfile in development but did not check
the resulting snapshot (Gemfile.lock) into version control

You have added to the Gemfile:
* roxml (~> 3.1, < 3.1.6)

You have deleted from the Gemfile:
* roxml (< 3.1.6, ~> 3.1)

I’ve searched in Google for this kind of errors, and everything I’ve found was dealing with .bundle directories, ignoring and tracking again the Gemfil.lock, … but nothing worked for me.

It was stupid of me not to follow some basic rules : what does the message tell? It’s telling that there is a difference between 2 versions. OK, but then there are the differences. It seems to be a matter of order in the version parameters.

All the gems in the Gemfile with none or only one version constraint were OK, and every one with two or more were listed in this error message.

The answer is really straightforward : let’s inverse the constraints, the ‘<’ before the ‘~>’. And it works!

Now I have the solution but not the explanation. I don’t have any idea why suddenly Bundler was picky like this. I didn’t even update it.

Update (quoting Andre Arko, maintainer of Bundler) :

This is an issue with Rubygems, which started calling .sort on the requirements list as of Rubygems 1.6 and higher. I’ve worked around it (just yesterday), and the fix will be in the next release of Bundler 1.0.x.

Voilà une idée bien saugrenue, je vous l’accorde. Pour comprendre, voyons un peu le contexte.

Nous avons développé une application iPhone pour HotelHotel (le site sur lequel je travaille). Elle fonctionne en interrogeant notre API interne pour effectuer des recherches d’hôtels. L’API interroge nos partenaires compare les prix et compose une liste de résultats renvoyée à l’application iPhone.

Pour les hôtels, nous disposons de plusieurs photos, qui aident à se faire un avis sur les hôtels proposés. Ces photos sont gérées par nous mêmes, nous indiquons juste leur URL à l’application distante.

Jusqu’à ces derniers jours, nous stockions ces photos sur notre propre serveur, mais pour différentes raisons, nous les avons déportées vers le service Amazon S3. Il y a plein d’avantages à utiliser ce service : haute disponibilité des contenus, bande passante très importante, pas de soucis de croissance de l’espace utilisé, … pour un coût très raisonnable.

Nous avons donc modifié les différentes parties de notre système pour que les fichiers soient placés sur Amazon S3 et les URL renvoyées aux navigateurs, application iPhone, … soient celle sur Amazon S3 et plus sur notre serveur.

Le problème

Jusqu’ici tout va bien, ou presque. Nos différents sites web (public, admin, …) fonctionnent bien, en lecture comme en écriture. Pa contre, l’appli iPhone plante et quitte dès qu’on veux charger une photo.

Après une séance de debuggage un peu déconcertante, on fini par trouver la source du problème. Pour bien comprendre, je rembobine un peu.

Pendant la phase de développement de l’appli iPhone, nous utilisions une version privée de l’API, sur un sous-domaine spécial, protégé par une authentification HTTP Basic. Juste avant la publication sur l’AppStore, nous avons changé le réglage pour pointer sur l’API de “production”, mais nous avons oublié d’enlever les en-têtes d’authentification.
On ne s’en est pas rendu compte car le serveur de production les ignorait. Il n’en attendait pas donc peu importe, il laissait tout passer.

Maintenant que les URL des images sont chez Amazon S3, et plus chez nous, ce sont leurs serveurs qui reçoivent les informations d’authentification. Manque de bol, leur serveur HTTP n’aime pas du tout les authentification de type HTTP Basic et il renvoi systématiquement une erreur 400 (Bad Request). Le contenu de la réponse est quant à lui une portion XML indiquant plus d’infos sur la requête, et c’est probablement ça qui fait planter l’appli. La librairie utilisée n’arrive probablement pas à gérer un contenu XML au lieu d’un contenu image.

Corriger l’appli iPhone pour supprimer l’authentification est très simple, mais il faut ensuite soumettre une nouvelle version à Apple (plusieurs jours de délai pour la valider) puis attendre que l’extrême majorité de nos utilisateurs mettent à jour l’appli, … Ce délai n’était pas envisageable.

La solution

Il m’est donc venue l’idée bizarre de mettre en place un moyen d’intercepter les URL demandées par l’iPhone, de les nettoyer des en-têtes d’authentification et de les transmettre à Amazon S3.

La mise en œuvre a été simple et rapide (grâce à l’aide de Grégory Colpart de Evolix). Nous avons créé un VirtualHost Apache sur un sous-domaine, dans lequel nous avons paramétré un reverse proxy. Toutes les requêtes envoyées à ce sous-domaines sont transmises de manière transparent à Amazon S3, et la directive RequestHeader supprime les en-têtes d’authentification.

Voilà la config du VirtualHost :

    <VirtualHost *:80>
      ServerAdmin webmaster@example.com
      ServerName s3tmp.example.com

      ProxyRequests Off
      <Proxy *>
        Order deny,allow
        Allow from all
      </Proxy>  

      ProxyPass / http://s3.example.com/
      ProxyPassReverse / http://s3.example.com/

      RequestHeader unset authorization
    </VirtualHost>

NB : “s3tmp.example.com” est le sous-domaine du proxy, “s3.example.com” est un alias vers Amazon S3

Contexte

Je souhaite quantifier le volume d’images transférées depuis un de mes serveurs. Le meilleur endroit pour trouver cette info me semble être les fichiers de logs d’Apache (ou autre serveur web) puisqu’ils indiquent l’URL demandée, le code HTTP et la taille du fichier transmis.

Une fois isolés les logs que je souhaite analyser, il ne me restait plus qu’à extraire les bons chiffres et en faire une somme.

Solution

grep '/system' * | grep -o -E '\b200 [0-9]+\b' | cut -f 2 -d ' ' | awk '{sum+=$0} END{print sum/1024/1024}'
Je vous décortique chaque étape du processus, séparées par le “pipe” (tuyau) qui sert à transmettre le résultat d’une commande à la suivante.

grep ‘/system’ *

grep permet de lire le contenu d’un fichier ou d’un flux et d’en extraire des parties, selon des règles et filtres. Je lui demande donc de lire tous les fichiers logs (le * à la fin), à la recherche de “/system” (la base des URLs qui m’intéressent).

J’obtiens donc toutes les lignes de log où une URL qui contient “/system” a été demandée.

Exemple :

178.48.252.123 - - [12/Dec/2010:07:12:11 +0100] "GET /system/images/missing-sq128.jpg HTTP/1.1" 200 2237 "http://www.hotelhotel.com/stylesheets/hh.css?1291888120" "Mozilla/5.0 (Windows; U; Windows NT 6.1; fr; rv:1.9.2.12) Gecko/20101026 Firefox/3.6.12"

grep -o -E ‘\b200 [0-9]+\b’

Les lignes sont analysées une nouvelle fois avec grep à la recherche d’une expression régulière qui permettra d’isoler les requêtes soldées par un code HTTP 200, indiquant que l’image a été effectivement téléchargée.

On utilise l’option -E pour indiquer qu’on veut les expressions régulières “étendues”. L’option -o indique qu’on ne veut renvoyer que ce qui a été capturé par l’expression, et pas tout la ligne.

L’expression indique qu’on souhaite capturer ce qui commence par “200″, précédé d’une rupture de mot (donc un espace, une ponctuation, …), puis un espace, une suite de chiffres, et une rupture de mot.

Exemple :
200 2237

cut -f 2 -d ‘ ‘

cut permet de découper la chaîne de caractère et de renvoyer seulement certaines portions de cette chaîne.

L’option -d on indique qu’on veut découper selon les espaces. L’option -f indique qu’on veut renvoyer le 2ème segment (la taille de l’image)

Exemple :
2237

À ce stade, on obtient une série de ligne qui contiennent les tailles des images téléchargées, il reste à en faire la somme

awk ‘{sum+=$0} END{print sum/1024/1024}’

awk est un outil aussi génial que les autres utilisés ici, mais je le connais très mal. C’est Colin qui m’a proposé cette dernière commande.

On demande donc à awk de faire la somme des valeurs trouvées à chaque ligne, de renvoyer cette somme, préalablement convertie en mega-octets (dans les logs Apache, ce sont des octets)

Conclusion

J’ai donc pu faire des opérations pas trop complexes, mais pas non plus triviales, en une seule ligne et avec un résultat immédiat.

Encore fois, ça prouve que bien connaître ses outils permet de travailler efficacement.

Inutile de dire que j’ai passé plus de temps à écrire ce petit article que pour construire cet enchaînement de commande, avec tous les essais/erreurs.

Après des mois de travail pour toute une équipe et un premier prototype (Wishbed pour ceux qui l’ont connu et essayé), Hotel Hotel fait sa sortie au monde ;-)

Le but est double :

1. proposer une recherche d’hôtel en ligne différente : plus d’hôtels sous la main, plus de chambres disponibles et les meilleurs prix.
2. apporter une information plus riche sur des destinations choisies : articles sur les villes, analyses complètes de ce qui se dit sur les hôtels (points positifs et négatifs, …)

C’est une première version. On a mille idées géniales à suivre, mais on ne voulait pas attendre plus longtemps pour bouleverser l’existant.

Faites le tour, essayez le, et surtout réserver des chambres d’hôtels. Vous verrez qu’on va vraiment vous aider à réduire vos frais d’hôtels !

Allez donc découvrir cette première version sur HotelHotel.com.

Vous nous trouverez aussi sur Twitter et sur Facebook.

If you don’t know about attr_accessor you’d define a getter and a setter :

class Foo
  def initialize(name = nil)
    self.name = name
  end
  def name
    @name
  end
  def name=(value)
    @name = value
  end
end

But you can do this in a much more concise way, like this

class Foo
  attr_accessor :name

  def initialize(name = nil)
    self.name = name
  end
end

With both approches, you can do this :

foo = Foo.new('Jérémy Lecour')
foo.name
#=> "Jérémy Lecour"
foo.name = 'John Appleseed'
#=> "John Appleseed"

You can dig a little deeper and get to know attr_reader and attr_writer to make only the getter or only the setter methods. The official documentation is the first place to be.

Well, that’s very good, predictable, … but as it happens, I needed to do something a little different and I’ve hit the wall.

I needed to apply some type casting on the values passed to the setter methods.

So I redefined the method for some attributes on my model. Let’s say I want to have my name capitalized :

class Foo
  attr_reader :name

  def initialize(name = nil)
    self.name = name
  end
  def name=(value)
    @name = value.upcase
  end
end

But I’ve seen something that I didn’t expect :

foo = Foo.new('Jérémy Lecour')
foo.name
#=> "JÉRÉMY LECOUR"
foo.name = 'John Appleseed'
#=> "John Appleseed"

That’s right, the setter method return the original value, not the implicit “return” that should (says me) return the capitalized verison of the parameter.

I’ve tried to change alittle bit and tried this :

class Foo
  attr_reader :name

  def initialize(name = nil)
    self.set_name name
  end
  def set_name(value)
    @name = value.upcase
  end
end

foo = Foo.new('Jérémy Lecour')
foo.name
#=> "JÉRÉMY LECOUR"

OK, that’s weird, the name of the method make the method behave differently, even if the “content” of the method is exactly the same.

With a little enlightment from the #ruby-lang people on IRC, I’ve learnt the concept of RHS (Right-Hand Side).

If you define an “assignment-like” method (with an equal sign at the end), Ruby will execute the method when you call it, but will always return the supplied parameter and never the result of the method.

As a result you can’t chain those methods, but it’s actually a good thing. For example :

foo = Foo.new()
bar = foo.name = 'John Doe'
foo.name
#=> "JOHN DOE"
bar
#=> "John Doe"

And by only reading the chained assignments, the result would not be obvious.

The lesson here has 2 points :
- you can’t chain assignent-like methods, so if you need such a thing, do it differently
- it is not a bug, it is a feature, and actually a good one when you understand the stakes

This has eaten at least 3 hours yesterday, so I thought it might benefit someone else.