planete php fr

Une étape dans le libre

Fri, 24 May 2013 14:00:39 +0200

A l'approche du salon "solutions linux", qui va se dérouler le 28 et 29 mai, dont vous pourrez me retrouver les stands :

AFUP (Association Française des Utilisateurs de PHP) avec la possibilité d'adoptée sur place des elePHPants.
DRUPAL, qui se situe juste à coté pour parler de ce CMS et du DrupalCamp de Paris en Juin prochain

Avec cette évènement, il était important de faire un tour d'horizon sur le libre en général, l'open source... directement à la radio "ici et maintenant" dans l'émission "Cyberculture".

L'émission se déroulera en direct de 14h00 à 15h30 en FM (95.2 Mhz) et à travers le web et le thème que je sera couvert est : "une étape dans le libre" avec un invité surprise.

Actualité de développement PECL, 2013 semaine 20 et 21

Thu, 23 May 2013 13:58:11 +0200

6 Paquets ont été mis à jour ces 2 dernières semaines :

Semaine 20 du 13 mai 2013

Semaine 21 du 20 mai 2013

Tags:

pecl

php

Actualité de développement PEAR, 2013 semaine 20 et 21

Wed, 22 May 2013 13:49:55 +0200

2 Paquets ont été mis à jour ces 2 dernières semaines :

Semaine 20 du 13 mai 2013

Aucun

Semaine 21 du 20 mai 2013

PEAR est la bibliothèque de composants PHP.

Tags:

pear

php

Un tiers des développeurs web devraient changer de boulot

Wed, 22 May 2013 10:59:40 +0200

…et quand je dis ça, c’est pour dire qu’ils devraient s’orienter vers n’importe quel travail qui soit loin, trèèès loin du développement informatique. Même la moindre macro Excel devrait leur être interdite.

Revenons un peu en arrière. J’ai déjà parlé plusieurs fois sur ce blog des comportements qui me font halluciner quand je fais passer des entretiens d’embauche.

Sur mes 12 années de carrière, je dois en être à pas loin de 10 ans à faire passer des entretiens. D’abord pour des stagiaires, puis pour des développeurs et par la suite pour des profils très variés.
Pendant longtemps, je faisais passer mes entretiens de manière très classique : je commençais par présenter l’entreprise, puis le candidat déroulait son CV, puis je posais des questions minutieuses sur ses expériences, pour enfin poser des questions techniques variées. Plus le temps passait, plus je me rendais compte que les entretiens se ressemblaient un peu trop ; à l’en croire, le candidat est à chaque fois un caïd faiseur de miracles ; en creusant un peu, je vois bien qu’il ne connaît pas la moitié des miracles qu’il est censé avoir fait ; sans parler des réponses parfois très exotiques à mes questions techniques…

Il y a quelques années, pour gagner du temps, j’ai changé ma manière de faire. Je commence dès le début de l’entretien par faire passer des petits tests techniques. Si ces tests se passent bien, on enchaîne (présentation de l’entreprise, déroulage du CV, questions-réponses). Si par contre le candidat échoue lamentablement aux tests techniques, je mets fin à l’entretien.

Cela peut paraître brutal, mais pour commencer je considère que mon temps est précieux (et si on regarde ma charge de travail, c’est une constatation, pas un fanfaronnade). Ce qu’il faut voir, surtout, c’est que les tests en question ne sont pas compliqués ; j’y vois un filtre me permettant d’identifier immédiatement les gros mauvais qui ne devraient pas vouloir être payés à coder.

Je ne vais évidemment pas dévoiler ici la teneur de ces tests (et je modérerais agressivement les commentaires qui le feraient). Mais sachez que je fais faire un test de programmation élémentaire, qui demande juste le minimum de logique algorithmique. En fait, je ne le vois même pas vraiment comme un test de programmation ; quand j’étais en école d’ingénieur, on l’utilisait pour expliquer la programmation à ceux qui n’en avaient jamais fait : «Vous connaissez les fonctions en mathématique, voici ce qu’est une fonction en informatique»

Et globalement, j’ai un tiers des candidats qui réussit le test sans problème ; un tiers qui sue sang et eau mais qui finit par y arriver ; et enfin un tiers qui échoue lamentablement d’une manière qui ne devrait pas exister.
Pour tout dire, j’ai déjà eu (trop) d’entretiens qui n’ont duré que 15 minutes, le temps de se rendre compte que le candidat n’y arrivera jamais, m’obligeant quelques fois à conclure en disant «Je suis désolé, monsieur, mais vous n’êtes pas informaticien».

Honnêtement, je n’éprouve aucun plaisir à dire ça à quelqu’un. Qu’il sorte tout juste d’école ou qu’il ait 10 ans d’expérience, je me sens toujours aussi mal. Mais soit le candidat se rend compte par lui-même qu’il n’a pas le niveau qu’il devrait avoir, soit il cherche des excuses ridicules ; et dans ce dernier cas, il me paraît parfois nécessaire de lui ouvrir les yeux.

Au cas où vous vous poseriez la question, j’affirme que cela ne dépend pas de la technologie utilisée. J’ai travaillé pendant 4 ans dans une start-up qui développait des services mobiles en Perl. Ce langage étant peu répandu en France, on recrutait de manière très ouverte, et on avait le même pourcentage d’échecs retentissants. J’ai travaillé pendant 1 an dans un environnement Java EE, et on ne recrutait que des développeurs expérimentés sur ces technologies ; et là encore, le taux était identique. Depuis 6 ans je recrute des développeurs PHP, et c’est la même chose.

Que faut-il conclure de ce constat préoccupant ? Je ne pense pas qu’il s’agisse d’un problème avec les formations. Même si elles se multiplient ? pour répondre à un besoin sans cesse croissant ? elles semblent continuer à fournir les mêmes quotas d’excellent, de moyens et de mauvais informaticiens.
Je pense plutôt qu’avec le temps, le nombre global d’informaticiens a été multiplié dans de grandes proportions. Et parce qu’on vit dans une ère de zapping, où il faut aller très vite (surtout dans les recrutements !), on tombe statistiquement plus souvent sur le fond du panier ? qui est comparativement plus représenté parmi les chercheurs d’emplois que le haut du panier, allez savoir pourquoi.
Facteur aggravant de ce phénomène, c’est de moins en moins par l’expérience professionnelle qu’on peut faire le tri dans les candidatures . Il faut rencontrer les gens pour les juger ; plus le niveau recherché est élevé, plus cela prend du temps pour le vérifier. C’est la raison pour laquelle cela prend moins de 15 minutes pour identifier quelqu’un qui n’est même pas informaticien. Après, entre un informaticien moyen et un bon informaticien, ça prend plus de temps pour faire le distinguo ; mais c’est une autre histoire.

Communiqué de presse de la Web-5

Tue, 21 May 2013 12:47:54 +0200

Comme promis dans le billet précédent, voici le communiqué de presse officiel pour la session 2013 de la Web-5 :

L’association Web-5 est une association à but non lucratif.

Dans le cadre de nos activités, nous organisons une conférence annuelle sur les nouvelles technologies du Web (front-end et back-end).
Notre premier évènement (http://conf2012.web-5.org) a été un franc succès. Nous avons été épaulés par des acteurs majeurs du développement Web tels que IBM, Mozilla, Zenexity, Wakanda, GitHub… et sommes parvenus à rassembler environ 120 personnes de 16 nationalités différentes !

Les sessions de la conférence se sont étalées sur 3 jours : 5 demi-journées de conférences et une d’atelier.
22 conférenciers ont pris la parole ce qui représente environ 20 heures de contenus d’un haut niveau d’expertise technique avec comme intervenants des personnalités telles que Robert Nyman, Michal Budzinsky et Sam Foster de la Fondation Mozilla, Christophe Jolif et Patrick Ruzand d’IBM, Philip Tellis (ex) Yahoo, Dylan Schiemann le co-fondateur de Dojo Toolkit et bien d’autres !

Cette année, la conférence Web-5 revient avec des sujets encore plus variés. Touchant aux problématiques rencontrées par les développeurs, administrateurs systèmes, architectes, designers, etc. dans leur travail quotidien.
Résolument technique, la conférence Web-5 proposera une nouvelle fois des talks de niveau expert, dédiés aux professionnels.
Cette fois nous proposons un format deux tracks, une session front-end (JavaScript, design, HTML5, real-time, accessibilité, testing, etc) et une session back-end (databases nosql, php, python, administration et monitoring, performance, etc).
Deux journées intenses qui, nous l?espérons, apporteront de nouvelles idées aux participants, ou confirmeront des choix techniques délicats grâce à l?expertise et l?expérience des speakers qu?ils pourront écouter et rencontrer.

Parce qu?il nous tient à coeur de démocratiser la technique et le savoir, nous avons travaillé avec nos partenaires afin de réduire au maximum le prix du ticket d?entrée. Permettant ainsi aux TPE-PME, aux freelancers, voire aux étudiants, de participer à cet événement qui, nous en sommes convaincus, sera enrichissant pour tous.

Pour plus d?information, vous pouvez consulter le site officiel : http://conf2013.web-5.org
Vous pouvez aussi nous suivre sur twitter : @web5_conf.

Rendez-vous les 14 et 15 Juin 2013 à Béziers pour la deuxième édition de la conférence Web-5 !

Agenda des prochains RDV dans les antennes locales de l'AFUP

Mon, 20 May 2013 00:00:00 +0200

A LYON

- Mardi 21/05, une conférence "AOP en PHP" : un RDV AFUP dédié à la programmation orientée aspect, lors d'une belle conférence qui avait rencontré un franc succès lors du PHP Tour Nantes 2012.

- Mercredi 22/05, l'AFUP Lyon tient une clinique PHP au banquet du Web. venez nous voir et présentez nous vos problèmes liés aux outils professionnels dans l'écosystème PHP, la performance et la sécurité.

- Mercredi 12/06, il s'agira cette fois d'une conférence "ezPublish et Symfony". Nicolas Pastorino proposera une présentation de ezPublish5, et plus particulièrement de son architecture désormais entièrement basée sur Symfony2. Inscrivez-vous dès maintenant.

Et, comme toujours, l'apéroPHP du 29 chaque mois ! Suivez le site des apéros PHP pour connaitre le lieu et l'heure.

A BORDEAUX

- Jeudi 23/05, l'antenne bordelaise vous propose une conférence/débat "Apache Vs Nginx". Abonnez-vous à la liste bordeaux@afup.org pour connaître tous les détails de ce rendez-vous.

A PARIS

- Les 28 et 29/05, l'antenne AFUP Paris sera présente au salon Linux pour tenir le stand de l'association. Nous serons ravis si vous venez nous saluer.

L'antenne parisienne vous prépare également un rendez-vous sur la sécurité en PHP, début juin. Restez à l'écoute pour connaître tous les détails de ce rendez-vous qui s'annonce très intéressant.

A très bientôt pour la suite des événements des antennes locales, partout en France !

Ecrire une application maintenable et testable

Sun, 19 May 2013 22:53:26 +0200

P { margin-bottom: 0.21cm; }A:link { }
Le site 'NetTuts+' propose un tutorial pour vous aider dans vos développements avec le langage PHP. L'article va expliquer comment écrire une application maintenable et testable avec ce langage. Ainsi, vous verrez les points suivants :

Tags:

Ecrire une application maintenable et testable

Sun, 19 May 2013 22:53:26 +0200

Tags:

Google App engine pour PHP

Sat, 18 May 2013 19:49:59 +0200

Il s'agit d'une nouvelle version majeure du Google App Egine, disponible dès maintenant. Ce moteur d'applications apporte de nombreuses évolutions et surtout il vient d'ajouter le support et la compatibilité avec le langage PHP sous la forme d'un PHP Runtime.

La conséquence directe pour les développeurs de ce langage, c'est de leur permettre de faire tourner des projets PHP, CMS... directement sur la plateforme cloud de Google.

Tags:

Conférence dotScale : la place est remportée, -20% pour les membres AFUP

Sun, 19 May 2013 00:00:00 +0200

Voilà une conférence qui va enfin répondre au besoin de bien des développeurs qui travaillent sur le cloud : dotScale ne traitera que du développement sur le Cloud, Big Data et DevOps. De quoi découvrir, avancer, comprendre et approfondir toutes vos connaissances, sans blabla et buzz marketing !

L’objectif de cette journée est d’aider les développeurs à comprendre les choix techniques derrière les plateformes qu’ils utilisent, afin d’architecturer leurs propres applications en conséquence pour les rendre scalables.

Membres AFUP, bénéficiez de 20% de réduction ! Achetez votre place dès maintenant.
La conférence se tiendra le 7 juin au Théâtre des variétés. Plus d'infos sur le site de dotScale.

Je serai à la Web-5 de Béziers

Thu, 16 May 2013 13:41:18 +0200

Salut à tous ! Ça roule ? Bon alors aujourd’hui, je vous annonce ma présence à la prochaine Web-5 à Béziers.

OK ça c’est bien gentil mais pourquoi aller à l’autre bout de la France ? Parce que j’y suis invité. C’est une raison valable à elle seule, non ? Mais il n’y a pas que ça.

Avec ma future camarade Camille, que je ne connais pas encore IRL, nous allons y assurer la couverture presse, ce pourquoi nous avons été invité. Vous allez donc entendre parler de Béziers dans les semaines à venir. Peut être même plus que de mon séjour à Montréal pour la ConFoo !
Donc déjà, je me demandais qui parmi vous sera présent là bas. J’adore rencontrer mes lecteurs, c’est toujours un super moment avec plein de trucs à apprendre (faut d’ailleurs que je relance les BeerJs). Alors, qui ?

Parlons donc un peu de la Web-5. Au planning, du web, du web et… Du web ! Plus sérieusement, des développeurs, des designers, des ergonomes, des experts référencement. Enfin du bon gros gratin. Et international en plus le gratin. Non content d’avoir invité des gens comme Raphaël Goetter d’Alsacréations, Stéphanie Walter de InPixelITrust (et aussi Alsacréations), Xavier Cambar, membre régulier de ParisJS, Julien Pauli, un poil connu dans le monde du PHP ou encore Alexandre Morgaut, l’un des big de boss du projet Wakanda chez 4D et membre du W3C. Ils ont aussi invité des grosses têtes étrangères, des mecs d’IBM, de Shazam, un dev du Zend Framework, de Thomson Reuters.

Pour la suite des évènements sur ce blog, je publierai prochainement le communiqué de presse. Puis suivront des interviews de différents orateurs. On va aussi sûrement expliquer avec Camille comment nous allons nous répartir les conférences et ce que vous pourrez espérer de nos prises de notes.

Ça se passe le 14 et 15 juin, à Béziers donc, il y aura des conférences passionnantes, des rencontres à faire, des soirées. Si vous ne l’avez pas, vous pouvez encore prendre votre place. Et puis bon, un détour dans le sud mi juin, vous savez quand il fait beau et bien chaud, ne me dites pas que ça ne vous donne pas envie

Pour deux jours, vous avez un billet individuel à 150?. Si vous venez à 5, il y a 20% de réduction avec les 5 places pour 600?. Moins cher que nombre de conférences à travers le monde. Pour un niveau franchement bon d’orateurs.

Ça se passe ici : http://conf2013.web-5.org/achetez-votre-ticket/

Navigation dynamique avec Backbone.js sur une carte OpenStreetMap

Wed, 15 May 2013 18:34:26 +0200

Il y a quelques ~~jours~~ semaines, nous avons vu comment créer une page spécifique dans Mezzanine pour afficher une carte grâce à OpenStreetMap. Nous allons poursuivre l’exercice et en faire une application un peu plus puissante. Notre but : permettre à un administrateur de rentrer lui-même différents « lieux » ou points intéressants, pour qu’ils puissent s’afficher sur la carte. Chaque point est cliquable, et dispose de sa propre url. Pour pousser un peu le raffinement, nous utiliserons Backbone.js pour que la navigation soit dynamique, et éviter la nécessité de recharger toute la page à chaque fois.

Des p’tits points? des p’tits points? encore des p’tits points !

Nous allons créer une application Django qui contiendra le code spécifique à la gestion de notre carte. Commençons par le modèle :

# models.py
from django.utils.translation import ugettext_lazy as _
from django.db import models
from mezzanine.core.fields import RichTextField
 
 
class PointOfInterest(models.Model):
    name = models.CharField(_('name'), max_length=50)
    description = RichTextField(_('Description'), null=True, blank=True)
    lat = models.FloatField(_('Latitude'))
    lng = models.FloatField(_('Longitude'))
    slug = models.SlugField(_('Slug'))
 
    class Meta:
        verbose_name = _('Point of interest')
        verbose_name_plural = _('Points of interest')
 
    def __unicode__(self):
        return self.name

Rien de trés compliqué jusque là ; chaque « lieu » dispose d’un titre, d’une description, et de coordonnées géographiques. L’activation du module d’admin est encore plus simple.

# admin.py
from django.contrib import admin
from city_map.models import PointOfInterest
 
 
class PointOfInterestAdmin(admin.ModelAdmin):
    prepopulated_fields = {"slug": ("name",)}
 
 
admin.site.register(PointOfInterest, PointOfInterestAdmin)

Configurons maintenant les urls de notre application :

# urls.py
from django.conf.urls import patterns, include, url
 
 
urlpatterns = patterns("city_map.views",
    # L'url racine, qui affiche la carte globale
    url('^$', 'map', name='map'),
 
    # Url spécifique affichant le détail de chaque lieu
    url('^(?P<slug>[\w-]+)/$', 'point_of_interest', name='point_of_interest'),
 
    # Nos markeurs seront disponibles en json
    url('^markers.json$', 'markers_data', name='markers_data'),
)

Les vues correspondantes ne contiennent absolument rien de compliqué.

# views.py
from django.http import HttpResponse
from django.core import serializers
from django.shortcuts import get_object_or_404
from django.utils import simplejson
from mezzanine.utils.views import render
from your_map_app.models import PointOfInterest
 
 
def map(request):
    return render(request, 'map.html')
 
def point_of_interest(request, slug):
    selected_poi = get_object_or_404(PointOfInterest, slug=slug)
    return render(request, 'map.html', {
            'selected_poi': selected_poi,
    })
 
def markers_data(request):
    pois = PointOfInterest.objects.all().values()
    data = simplejson.dumps(list(pois))
    return HttpResponse(data, mimetype='application/json')

Tout est en place, il ne nous reste plus qu’à récupérer les données json pour les afficher sur la carte. Dans le template écrit la dernière fois, remplacez le bloc extra_js par celui-ci :

<script type="text/javascript">
 
// This function is called whenever the map is ready
function citymapInit(map, bounds) {
    $.getJSON('{% url 'markers_data' %}', function(data) {
        $.each(data, function(key, val) {
            var link = getMarkerLink(val);
            L.marker([val['lat'], val['lng']]).addTo(map).bindPopup(link);
        });
    });
}
 
function getMarkerLink(json) {
    // Returns a correct link to the point of interest url
 
    var url_root = '{% url 'map' %}';
    var url = url_root + json['slug'] + '/';
    return '<a href="' + url + '">' + json['name'] + '</a>';
}
</script>

Si tout s’est bien passé, chaque marqueur dispose maintenant d’un lien qui permet d’accéder à l’url du lieu. Pas mal, non ?!

Un peu de dynamisme avec Backbone.js

Notre carte est bien sympathique, mais elle manque un peu de dynamisme. Chaque clic génère un rechargement complet de la page, ce qui va vite devenir fastidieux. Nous allons donc ajouter une couche de javascript qui va y remédier. Et pas n’importe quel javascript s’il vous plaît ! Nous allons utiliser Backbone.js.

Il fut un temps ou la création d’applications web dynamiques et single page apps se faisait difficilement sans l’apparition de code jquery spaggheti particulièrement dégueulasse. Du js mélangé au html, des données stockées dans le dom, etc. Tout cela n’était pas sans rappeler le bon vieux temps pré-frameworks MVC ou PHP, HTML et requêtes SQL s’imbriquaient lubriquement sans la moindre pudeur.

Heureusement, le monde Javascript a lui aussi gagné en maturité et de (trop ?) nombreux outils sont apparus pour remédier à ce problème. L’un des premiers et plus populaires est Backbone.js, que l’on qualifiera (pour simplifier de manière éhontée) de framework MVC côté client.

Concrètement, Backbone.js fournit les outils pour gérer les données et leurs traitement via leurs propres classes ; il (ou elle ?) offre des vues pour gérer l’UI et rendre des templates à partir des données des modèles ; elle gère les événements pour permettre la synchronisation entre les interactions de l’utilisateur et les modifications des données ; elle propage l’enregistrement des données sur le serveur via des appels ajax à une api json ; elle propose une navigation en se basant sur l’API History. Bref ! Backbone fait pas mal de trucs.

En revanche, Backbone.js est plus une librairie qu’un véritable framework, en ce sens qu’elle n’impose pas de structure à votre application. Le cas échéant, on lui adjoindra une surcouche comme Marionette.js, ou on préférera un vrai framework comme Angular.js.

Notre utilisation de Backbone sera trés simple puisque notre appli sera read only. Mais c’est un bon début pour se mettre le pied à l’étrier.

Du dynamique sans la bolognaise

Reprenons notre template map.html, effaçons notre bloc extra_js, et remplaçons-le par ceci :

 
// La librairie backbone et sa dépendance
<script src="{{ STATIC_URL }}js/underscore.js"></script>
<script src="{{ STATIC_URL }}js/backbone.js"></script>
 
// C'est dans ce fichier que nous allons développer notre appli Backbone
<script src="{{ STATIC_URL }}js/map/app.js"></script>
 
<script type="text/javascript">
// Il nous faudra passer des paramètres de Python à Javascript
App.Config = {
    // L'adresse à laquelle récupérer les marqueurs en json
    markerCollectionUrl: "{% url 'markers_data' %}",
 
    // L'url courante de la carte
    mapUrl: "{% url 'map' %}"
};
 
function citymapInit(map, bounds) {
    // Quand la carte est prête, nous lançons l'application
    App.start(map);
}

Notre application Backbone va définir un objet racine App, qui va entre autre contenir les paramètres de configuration, et son point d’entrée sera la fonction start, que nous appelerons pour lancer le schmilblick. Bon, et si nous y jetions y coup d’?il, à cette fameuse application ?

// your_map_app/static/js/map/app.js
 
var App = {
    Models: {},
    Collections: {},
    Views: {},
    Routers: {},
    Config: {}
};

Nous commençons par définir notre objet App, qui servira de conteneur pour toute l’appli. Backbone nous offre des outils pour déclarer des modèles et des collections, destinées à recevoir des listes de modèles.

 
// Nous n'aurons pas de traitements à effectuer, aussi
// notre modèle est-il vide
App.Models.Marker = Backbone.Model.extend({});
 
// L'API Backbone permet, une fois la collection déclarée, de
// l'initialiser à partir de données json sans difficultés
// particulières
App.Collections.MarkerCollection = Backbone.Collection.extend({
    model: App.Models.Marker,
    initialize: function() {
        this.url = App.Config.markerCollectionUrl;
    },
    getBySlug: function(slug) {
        return this.findWhere({ slug: slug });
    }
});

Nous avons défini la partie modèle de notre application. Les classes en question sont bien vides, vu que nous sommes en read only. Nous allons maintenant définir les vues. Dans Backbone, les vues sont des classes chargées d’effectuer des actions (rendre un template, par exemple) en fonction d’un modèle ou d’une collection et des événements qui y sont rattachés.

 
// MarkerView est une classe à laquelle on passe un marqueur,
// et qui sera chargée de l'afficher sur la carte via
// l'API Leaflet
App.Views.MarkerView = Backbone.View.extend({
 
    // fonction lancée à l'instanciation de la vue
    initialize: function(options) {
 
        // L'objet map (API Leaflet) doit être passé en paramètre
        this.map = options.map,
 
        // Create the marker using leaflet api
        // Notez l'api d'accès aux données du modèle
        this.marker = L.marker([this.model.get('lat'), this.model.get('lng')]);
 
        // Create the marker popup
        var popup = document.createElement('a');
        popup.href = App.Config.mapUrl + this.model.get('slug') + '/';
        popup.innerHTML = this.model.get('name');
 
        // We have to bind the event here, because leaflets prevents
        // the click event to bubble outside the map element
        var slug = this.model.get('slug');
        popup.onclick = function(event) {
            event.preventDefault();
            // Lorsque l'internaute clique sur le lien, nous
            // indiquons à Backbone qu'un changement d'url doit être
            // intercepté
            Backbone.history.navigate(slug + '/', true);
        };
        this.marker.bindPopup(popup);
 
        // Render the marker to the map
        // (Leaflet API)
        this.marker.addTo(this.map);
    }
});
 
// MapView est la vue principale. Elle va instancier la collection des marqueurs
// et les afficher un par un
App.Views.MapView = Backbone.View.extend({
    initialize: function(options) {
        this.map = options.map;
        this.markers = new App.Collections.MarkerCollection();
 
        // Nous téléchargeons les données json pour instancier
        // la collection. Dés que c'est fait, on lance la fonction
        // de rendu.
        this.listenTo(this.markers, "reset", this.render);
        this.markers.fetch({ reset: true });
    },
    render: function() {
        this.markers.each(this.addOne, this);
        return this;
    },
    addOne: function(marker) {
        var view = new App.Views.MarkerView({
            model: marker,
            map: this.map
        });
    },
    getMarkerBySlug: function(slug) {
        return this.markers.getBySlug(slug);
    }
});
 
// Cette vue permettra de mettre à jour la page à partir d'un
// marqueur donné
App.Views.MainView = Backbone.View.extend({
    initialize: function() {
        this.descriptionElement = $('#poi-main');
        this.titleElement = $('h1');
        this.sidebarElement = ('#poi-sidebar');
        // Nous utiliserons un template pour le rendu de la
        // sidebar. Nous le définirons un peu plus tard
        this.sidebarTemplate = _.template($('#poi-sidebar-template').html());
    },
    render: function() {
        this.descriptionElement.html(this.model.get('description'));
        this.titleElement.html(this.model.get('name'));
        this.sidebarElement.html(this.sidebarTemplate(this.model.attributes));
    },
});

Même si l’API utilisée peut dérouter dans un premier temps, le code est relativement simple. Une vue principale, MapView, récupère les données via l’API en instanciant une collection, puis pour chaque marqueur délègue son affichage en instanciant une vue spécifique.

Nous avons notre modèle, nos vues. Il manque? le? le? controleur ! Bravo à ceux qui suivent.

 
// Dans l'API Backbone, un router permet de déclarer les différentes
// urls disponibles, et de faire correspondre un traitement spécifique
// à chacune d'entre elles
App.Routers.MapRouter = Backbone.Router.extend({
    initialize: function(options) {
        // Nous n'utiliserons que deux urls pour notre appli
        this.route('', 'map');
        this.route(':slug/', 'pointOfInterest');
 
        // instancions maintenant les vues principales
        this.mapView = new App.Views.MapView({ map: options.map });
        this.mainView = new App.Views.MainView();
    },
    map: function() {
        // La carte est déjà affichée, rien à faire ici
    },
    pointOfInterest: function(slug) {
        // L'utilisateur vient de cliquer sur un lien, il
        // faut afficher le marqueur correspondant
 
        // Récupérons le marqueur en question, à partir du "slug" passé en url
        var marker = this.mapView.getMarkerBySlug(slug);
 
        // Il nous suffit de passer le bon marqueur à la vue
        // et de la laisser s'occuper du rendu
        this.mainView.model = marker;
        this.mainView.render();
    }
});

Il manque une chose à notre appli. Notre point d’entrée, la fameuse fonction start. Son seul but est d’initialiser le contrôleur.

App.start = function(map) {
    var mapRouter = new App.Routers.MapRouter({ map: map });
    Backbone.history.start({
        pushState: true,
        root: App.Config.mapUrl,
        silent: true,
    });
};

Tadaaaam ! Le résultat est visible sur ce site de démo, et le code est sur Github. Dans le prochain billet, j’essaierai d’employer encore plus de technos hype d’un coup.

photo by: Luz Adriana Villa A.

Cet article Navigation dynamique avec Backbone.js sur une carte OpenStreetMap est apparu en premier sur Miximum.

La programmation n'est pas industrialisable

Wed, 15 May 2013 14:00:00 +0200

Je poursuis ici ma réflexion entamée dans mon précédent billet concernant la difficulté de certaines personnes à comprendre qu?il est impossible de quantifier finement et surtout de manière fiable le temps nécessaire à la réalisation d?un logiciel.

Plus j?y pense, plus je me dis que le problème vient du fait que la personne qui demande un tel chiffrage à un développeur pense que la création d?un logiciel est le résultat d?une industrialisation.

Dans notre contexte, la définition la plus adéquate de l?industrialisation est la suivante, d?après Wikipedia :

L?industrialisation désigne le processus de transfert du processus de création de l?offre au processus de réalisation de l?offre.

En résumé, lors de la phase d?industrialisation d?un produit, l?ensemble de la phase de conception de ce produit a été réalisé et il est donc possible de définir précisément les étapes devant être successivement suivies pour l?obtenir à l?extrémité de la chaîne de production.

De plus, puisqu?au moins un exemplaire du produit existe dans le monde réel à l?issue du processus de création, il est possible de quantifier très précisément les ressources temporelles et matérielles qui seront nécessaires pour sa fabrication à grande échelle.

Enfin, pour la même raison, ses spécifications sont clairement définies et il est donc possible de s?y référer afin d?effectuer tout au long de la chaîne de fabrication des contrôles précis pour vérifier la qualité du produit final.

En résumé, l?industrialisation permet de dupliquer à grande échelle le produit conçu lors de la phase de création en s?assurant de sa qualité et en maîtrisant les coûts au plus juste, car l?ensemble de ses caractéristiques est connu précisément.

Or, n'en déplaise à certains, le développement logiciel est par essence une activité créative, au même titre que l?écriture d?un livre, la réalisation d?un dessin ou d?une peinture ou l?élaboration d?une nouvelle théorie mathématique.

En effet, si le programme existait déjà, personne ne demanderait à un développeur de l?écrire, donc de le créer?

La conception de logiciel ne peut donc être industrialisée puisque comme nous l?avons constaté précédemment, il est indispensable de disposer d?au moins un exemplaire physique pour pouvoir estimer précisément les ressources nécessaires à sa fabrication à grande échelle et avoir les informations nécessaires aux divers contrôles de qualité.

Il est donc très délicat sinon impossible d?estimer de manière fiable les ressources humaines, techniques et temporelles nécessaires à la conception d?un logiciel, et encore plus difficile de définir les spécifications permettant de s?assurer qu?il répond bien aux besoins.

J'en connais qui me rétorqueront qu?il est tout de même possible d?industrialiser à minima le développement d?un logiciel à l?aide de framework et autres briques logicielles « clef en main ».

Cependant, la colle nécessaire pour assembler ces briques afin d'obtenir le programme demandé devra être inventée et nécessitera donc toujours un effort créatif.

En conséquence, même en recourant à de tels outils, il reste impossible de donner une estimation précise et fiable du temps nécessaire à la réalisation d?un programme.

Car en réalité, les frameworks et autres briques logicielles ne permettent pas d?industrialiser le processus de développement d?un logiciel.

Ils facilitent uniquement la vie du développeur en lui permettant d?utiliser du code en théorie de bonne qualité, correctement documenté et conçu pour répondre aux besoins essentiels et communs à la plupart des programmes.

Évidemment, cela lui permet de développer plus rapidement son programme, mais ce n?est pas pour cela qu?il pourra estimer plus précisément le temps qu?il mettra à le concevoir dans son intégralité, d?autant que parfois, ces outils peuvent au contraire lui faire perdre du temps indépendamment de sa volonté.

De même, certains outils tels que les frameworks de tests unitaires ou fonctionnels ainsi que certaines méthodologies comme le TDD permettent effectivement d?estimer la qualité du code, tout comme les méthodes agiles permettent d?estimer le temps nécessaire à la réalisation d?un ensemble de tâches en se basant sur le temps passé précédemment pour réaliser d?autres tâches plus ou moins complexes.

Cependant, ces estimations sont empiriques et n?ont donc pas la précision absolue et intangible de celles ayant court dans le cadre d?un processus industrialisé.

En conclusion, demander à un développeur le temps qu?il mettra à développer un logiciel n?est pas la même chose que demander à un peintre en bâtiment le temps qu?il va mettre et le nombre de pots de peinture dont il aura besoin pour peindre un mur de 12 m² en vert.

C?est en fait comme demander, s?ils étaient encore de ce monde, à Léonard de Vinci le temps qu?il va mettre à peindre le tableau d?une femme posant devant un paysage ou bien à Albert Einstein le temps qu?il lui faut pour inventer une théorie expliquant la relation entre l'espace, le temps, et peut être éventuellement d'autres paramêtres.

Et je suis prêt à parier que dans les deux cas, la réponse serait du style « un certain temps ».

Revue de presse industrialisation semaines 19-20

Tue, 14 May 2013 11:54:20 +0200

Le temps passe, PHP et ses communautés continuent à évoluer à grands pas ! De PHP à JavaScript Pour commencer cette revue de presse, un petit clin d'oeil à atoum, le fameux framework de tests unitaires en PHP, qui désormais dispose d'un fork en JavaScript développé par Julien Bianchi. Outils - console PHP Quoi de [...]

Tester l?existence d?une fonction Javascript

Mon, 13 May 2013 23:27:17 +0200

Ci-dessous une petite astuce Javascript pour vérifier qu’une fonction est définie ou non. Le comportement rappelle la fonction « function_exists() » en PHP. Le test se base sur la fonction Javascript typeof() qui renvoi functionsi le handler passé est déclarée comme fonction. Il suffit de décommenter ‘mafonction’ pour constater que l’existence de la fonction est correctement prise en compte. Pour vérifier si un handler est utilisé comme une fonction ou comme une variable, vous pouvez utiliser le [...]

PHP 5.4.15 et 5.3.25 et 5.5.0RC1

Sat, 11 May 2013 21:14:44 +0200

L'équipe de développement PHP vient de publier 3 nouvelles versions de PHP, concernant les branches :

PHP 5.3 (5.3.25)
PHP 5.4 (5.4.15)
PHP 5.5 (5.5.0 rc 1)

Les 2 premières versions correspondent au cycle de vie des mises à jours mensuel de PHP. Elles corrigent plus de 10 bugs et la Team de PHP Group encourage de mettre à jour vos différentes versions. Pour connaître l'ensemble des points , vous pouvez consulter le fichier de 'changeLog'.

Tags:

php

5.5

PHP 5.4.11 et 5.3.21 et 5.5.0RC1

Sat, 11 May 2013 21:14:44 +0200

L'équipe de développement PHP vient de publier 3 nouvelles versions de PHP, concernant les branches :

PHP 5.3
PHP 5.4
PHP 5.5

Tags:

php

5.5

Caranille 3.5

Fri, 10 May 2013 13:13:25 +0200

Caranille est un MMORPG (massively multiplayer online role-playing game), c'est à dire un jeu de rôle pour le web, sous licence GNU GPL, réalisé en PHP5 et MySQL. Il va vous permettre de concevoir et bâtir rapidement votre propre environnement de jeu, utilisable en multijoueur.

Ce logiciel propose une gestion modulable en créative commons, avec la possibilité de contribuer et de développer vos propres modules en PHP.

Tags:

Caranille 3.5

Fri, 10 May 2013 13:13:25 +0200

Ce logiciel propose une gestion modulable en créative commons, avec la possibilité de contribuer et de développer vos propres modules en PHP.

Tags:

Les stands PHP au salon solutions linux 2013

Thu, 09 May 2013 14:20:43 +0200

Le salon « solutions linux » va se dérouler le 28 et 29 mai 2013 au Cnit à Paris. Et de nombreuses sociétés Open source seront présentes, ainsi que de nombreux acteurs du langage PHP.

Au niveau du village associatif, le langage PHP sera aussi représenté avec les associations comme Dolibar, AFUP (Association Française des Utilisateurs de PHP), Drupal, GLPI...

Pour ma part, je vais m'occuper des stands AFUP et Drupal, situé sur les stands A34 et A32, mais aussi de nombreuses acteurs de ces communautés seront présents pour répondre à toutes vos questions et bien sur parler de CMS ou encore du langage PHP.

Par ailleurs, les elePHPants bleus et rose, effectueront le déplacement pour rechercher de nouvelles familles d'accueils et surtout ils adorent faire des calins, c'est pourquoi il ne faudra pas être surpris de leurs demandes.

Mais sans plus attendre, il faut vous inscrire gratuitement sur le stand du salon linux pour venir nous voir.

Le salon Solutions Linux qui se déroule du 28 et 29 mai 2013