Archives par étiquette : développement

JavaScript, un peu d’héritage

Bien le bonjoir, parlons un peu de Javascript. Ce langage dynamique nous donne une grande liberté qui se paye parfois par une multitude de possibilités d’implémentations y compris pour les concepts de base.

Pour faire simple, si vous voulez de l’héritage, vous vous codez ce dont vous avez envie. C’est le côté chiant coût de la liberté. Nous allons faire un petit tour pour comprendre les mécanismes de base et aborder différentes façons d’implémenter l’héritage.

Le chaînage de prototype

 Javascript ne propose pas de la programmation objet classique, mais une programmation orienté prototype qui peut être assez perturbante. Le langage ne se base pas sur des classes mais sur l’instanciation d’objets, les prototypes, qui servent de modèles pour créer de nouveaux objets. 

Les fonctions possèdent une propriété appelée prototype contenant un objet. Lorsque nous utilisons le mot clé « new » sur une fonction, un nouvel objet est créé à partir de l’objet prototype, il contient un lien caché vers ce prototype (nommé parfois __proto__).  Il n’y a pas que les fonctions, tous les objets possèdent un lien caché qui pointe vers un prototype. Le chemin qui permet de remonter successivement les liens vers les prototypes est appelé chaîne de prototype. L’objet dont le prototype est null fini la chaîne de prototype.

Un petit bout de code très basique pour voir ce mécanisme, ouvrez une console et tapez :

var func = function(text) {};
// the function prototype
console.log('func prototype : ' + func.prototype);
// the prototype of the function prototype
console.log('func prototype.__proto__: ' + func.prototype.__proto__);
// the top parent prototype is null, it is the final link in the prototype chain
console.log('func prototype.__proto__.__proto__: ' + func.prototype.__proto__.__proto__);

Ce qui nous donne :

func prototype : [object Object]
func prototype.__proto__: [object Object]
func prototype.__proto__.__proto__: null

Ce chaînage de prototype prend tout son sens lorsqu’on regarde la résolution de propriété sur un objet. Nous commençons par chercher la propriété sur l’objet, puis nous allons voir du coté du prototype et ainsi de suite jusqu’à atteindre la fin de la chaîne.

L’héritage « classique »

Justement, cet héritage profite du chaînage de prototype. Prenons un exemple d’objets :

//Shape constructor
function Shape(){
    this.name = 'shape';
    this.toString = function() {
        return this.name;
    }
};
//TwoDShape constructor
function TwoDShape(){
    this.name = '2D shape';
};
//Triangle constructor
function Triangle(side, height){
    this.name = 'Triangle';
    this.side = side;
    this.height = height;
    this.getArea = function() {
        return this.side * this.height / 2;
    }
};

L’héritage va se faire via ces simples lignes de code :

TwoDShape.prototype = new Shape();
Triangle.prototype = new TwoDShape();

L’héritage passe ici par l’affectation de l’instance de l’objet parent au prototype de l’objet enfant. Ce mécanisme découple chaque objet de l’héritage. Concrètement, si nous modifions  Shape après avoir fait l’héritage, ça n’aura aucun impact sur TwoDShape.

C’est le constructor qui est appelé pour instancier de nouveaux objets à partir du prototype. Dans le cas de notre héritage, nous écrasons le prototype et le constructeur qui va avec. Pour éviter des effets de bord, spécifions le bon constructeur :

TwoDShape.prototype.constructor = TwoDShape;
Triangle.prototype.constructor = Triangle;

Nous pouvons instancier un Triangle

var myTriangle = new Triangle(2, 5);
myTriangle.getArea(); // 5

Il existe un mot clé : instanceof qui teste si un objet possède la propriété prototype d’un constructeur donné dans sa chaîne prototype.

Faisons quelques tests :

myTriangle instanceof Shape; // true
myTriangle instanceof TwoDShape; // true
myTriangle instanceof Triangle; // true
myTriangle instanceof Number; // false

Nous obtenons la même chose en partant du prototype avec la méthode isPrototypeOf :

Shape.prototype.isPrototypeOf(myTriangle); // true
TwoDShape.prototype.isPrototypeOf(myTriangle); // true
Triangle.prototype.isPrototypeOf(myTriangle); // true
Number.prototype.isPrototypeOf(myTriangle); // false

Maintenant, regardons d’où viennent les méthodes, pour cela nous allons utiliser hasOwnProperty :

var triangle = new Triangle(5,4);

triangle.hasOwnProperty('getArea'); //getArea is a Triangle property: true
triangle.hasOwnProperty('toString'); // toString is a Triangle property: false

var twoDShapePrototype = Object.getPrototypeOf(triangle);
twoDShapePrototype.hasOwnProperty('toString'); //toString is a TwoShape property: false

var shapePrototype = Object.getPrototypeOf(twoDShapePrototype);
shapePrototype.hasOwnProperty('toString'); //toString is a Shape property: true

Un prototype pour tous

Nous pouvons nous dire que finalement tout le code à partager se retrouve dans le prototype. Histoire de limiter le temps de résolution des propriétés, référençons directement un seul prototype.

function Shape() {
};
Shape.prototype.name = 'Shape'
Shape.prototype.toString = function () {
    return this.name;
}

function TwoDShape() {
};
TwoDShape.prototype = Shape.prototype;
TwoDShape.name = '2D shape';

function Triangle(side, height) {
    this.side = side;
    this.height = height;
};
Triangle.prototype = TwoDShape.prototype;
Triangle.prototype.name = 'Triangle';
Triangle.prototype.getArea = function () {
    return this.side * this.height / 2;
}

var myTriangle = new Triangle(2, 5);
myTriangle.getArea(); // 5
myTriangle.toString(); // Triangle

Cette fois-ci, la résolution de la méthode toString() se passe en deux étapes au lieu de quatre. Triangle ne possède pas la méthode, nous regardons dans le prototype, il référence le prototype de Shape et nous avons directement toString.

Vous vous doutez que ça pose quand même un gros problème 😉 . Toutes les modifications sur le prototype impactent toute la hiérarchie.

var myShape = new Shape();
myShape.toString(); // Triangle

Utilisation d’un constructeur temporaire

Un constructeur temporaire est utilisé pour hériter seulement du prototype du parent. Il utilise le chaînage de prototype.

//Shape constructor
function Shape() {
    this.justAShape = true;
};
Shape.prototype.name = 'Shape';
Shape.prototype.toString = function () {
    return this.name;
};
//TwoDShape constructor
function TwoDShape() {    
};
var F = function () {
};
F.prototype = Shape.prototype;
TwoDShape.prototype = new F();
TwoDShape.prototype.constructor = TwoDShape;
TwoDShape.prototype.name = '2D shape';
//Triangle constructor
function Triangle(side, height) {
    this.side = side;
    this.height = height;
}
var F = function () {
};
F.prototype = TwoDShape.prototype;
Triangle.prototype = new F();
Triangle.prototype.constructor = Triangle;
Triangle.prototype.name = 'Triangle';
Triangle.prototype.getArea = function () {
    return this.side * this.height / 2;
};

var myTriangle = new Triangle(5, 2);
myTriangle.getArea();// 5
myTriangle.toString();// triangle
myTriangle.hasOwnProperty('toString'); // false
Object.getOwnPropertyNames(myTriangle) //side,height

var myShape = new Shape();
myShape.toString(); // Shape
Object.getOwnPropertyNames(myShape); //justAShape

En utilisant ECMAscript 5

ECMAscript 5 fourni une méthode Object.create qui permet d’instancier un objet à partir d’un prototype. Cette méthode donne un réel contrôle sur la création d’objet et du coup, nous pouvons nous passer complètement du code de constructeur temporaire.

//Shape constructor
function Shape() {
    this.justAShape = true;
};
Shape.prototype.name = 'Shape';
Shape.prototype.toString = function () {
    return this.name;
};
//TwoDShape constructor
function TwoDShape() {    
};

TwoDShape.prototype = Object.create(Shape.prototype);
TwoDShape.prototype.constructor = TwoDShape;
TwoDShape.prototype.name = '2D shape';
//Triangle constructor
function Triangle(side, height) {    
    this.side = side;
    this.height = height;
}
Triangle.prototype = Object.create(TwoDShape.prototype);
Triangle.prototype.constructor = Triangle;
Triangle.prototype.name = 'Triangle';
Triangle.prototype.getArea = function () {
    return this.side * this.height / 2;
};
var myTriangle = new Triangle(5, 2);
myTriangle.getArea();// 5
myTriangle.toString();// triangle

myTriangle.hasOwnProperty('toString'); // false
Object.getOwnPropertyNames(myTriangle) //side,height

var myShape = new Shape();
myShape.toString(); // Shape
myShape.justAShape; // true
Object.getOwnPropertyNames(myShape); //justAShape

Alors pourquoi se servir d’un constructeur temporaire si Object.create fait le boulot ? Tout simplement pour le support des navigateurs. Si vous regardez la documentation MDN, vérifiez bien les versions supportées ! Pour Objet.create, nous avons : chrome 5+, Firefox 4.0+, IE9+, Opera 11.60+, Safari5+.

Si vous préférez hériter également des propriétés des objets en plus du prototype, il suffit d’appeler le constructeur du parent dans le constructeur enfant :

function Shape() {
    this.justAShape = true;
};
Shape.prototype.name = 'Shape';
Shape.prototype.toString = function () {
    return this.name;
};
//TwoDShape constructor
function TwoDShape() {    
    Shape.call(this);
};

TwoDShape.prototype = Object.create(Shape.prototype);
TwoDShape.prototype.constructor = TwoDShape;
TwoDShape.prototype.name = '2D shape';
//Triangle constructor
function Triangle(side, height) {
    TwoDShape.call(this);
    this.side = side;
    this.height = height;
}
Triangle.prototype = Object.create(TwoDShape.prototype);
Triangle.prototype.constructor = Triangle;
Triangle.prototype.name = 'Triangle';
Triangle.prototype.getArea = function () {
    return this.side * this.height / 2;
};
var myTriangle = new Triangle(5, 2);
myTriangle.getArea();// 5
myTriangle.toString();// triangle

myTriangle.hasOwnProperty('toString'); // false
Object.getOwnPropertyNames(myTriangle) //justAShape,side,height
myTriangle.justAShape; // true

var myShape = new Shape();
myShape.toString(); // Shape
myShape.justAShape; // true
Object.getOwnPropertyNames(myShape); //justAShape

 

Le futur avec ECMAScript 6

Cette version d’ECMAScript est appelée Harmony et reste à l’état de discussion, du coup, tout ce nous pouvons comprendre à l’heure actuelle pourrait évoluer. Vous pouvez jeter un coup d’œil au draft en cours. La dernière version au moment ou j’écris l’article est datée du 27 avril 2014, et il faut avouer que c’est relativement illisible :p

J’ai commencé par essayer de déchiffrer la partie 14.5.17 Runtime Semantics: ClassDefinitionEvaluation , comme j’étais perplexe devant ce document, j’ai cherché des exemples concrets sur le wiki ecmascript.org. L’exemple nous montre que cette version permet une écriture plus proche de ce que nous connaissons dans les autres langages. Pour faire simple, disons qu’il s’agit de sucre syntaxique pour nous faciliter la vie. J’ai voulu tester en cherchant comment utiliser class et je suis tombé sur une table des compatibilités ECMAScript 5/6. Je n’ai pas pu tester directement mais j’ai découvert Tracer Compiler, l’espoir fut de courte durée car ce n’est pas encore supporté.

Bref, contentons nous d’imaginer ce nous pourrions écrire :

class Shape {
    private name = "Shape";
    
    constructor(){
       public justAShape = true;
       private(this).name = "Shape";
    }        

    get name() {
        return private(this).name;
    }

    public toString() {
        return this.name;
    } 
}

class TwoDShape extends Shape {
    constructor(){
       super()
       private(this).name = "2D shape";
    }        
}

class Triangle extends TwoDShape {
    constructor(side, height) {
        super();
        public side = side;
        public height = height;
        private(this).name = "Triangle";
    }
    
    public getArea() {
       return this.side * this.height / 2;
    }
}

 

Conclusion

Javascript nous laisse beaucoup de liberté, un peu trop diront certains, et il existe bien d’autres façons d’implémenter l’héritage. Le futur nous amène une syntaxe plus consensuelle  dans la lignée des autres langages, mais il s’agit surtout de sucre syntaxique. Ce que je retiens, c’est qu’en prenant le temps de réfléchir à l’héritage, nous voyons qu’il est important de :

  • comprendre le fonctionnement des prototypes
  • vérifier que la version de javascript que nous utilisons est compatible avec les navigateurs ciblés
  • prendre le temps de lire les documentations officielles et de tester le comportement directement dans un (ou plusieurs) navigateur(s)

En rédigeant cet article, j’ai découvert Tracer Compiler et j’ai mieux compris l’intérêt des Polyfill même dans le cas d’implémentations basiques. Ça m’encourage d’autant plus à tester mon code sur différents navigateurs (du coup, article sur Karma à venir 😉 )!

Références

Codecademy – L’école des padawans développeurs

Aujourd’hui, je vais vous parler de Codecademy, une plateforme d’apprentissage de développement en ligne.

Premiers pas

Vous pouvez attaquer votre apprentissage de deux façons :

  • Soit un cours parmi une liste  (Javascript, HTML/CSS, PHP, Python ,Ruby, APIs)
  • Soit réaliser des mini projets

Le cours

J’ai testé le cours de javascript :

  • Chaque chapitre représente une grande notion
  • Un chapitre propose une série d’exercices ciblés
  • Chaque passage de notion propose un exercice plus complet
  • Le cours est progressif et parfaitement adapté pour les débutants

Les mini projets

Il s’agit d’une suite d’exercices pour réaliser un mini projet en 30 min max. Le but est de vous familiariser avec la syntaxe et certaines particularités de la technologie.

Vous pouvez également réaliser et partager vos propres expérimentations.

Gamification & profil

Badges & points vous sont décernés au fur et à mesure de votre progression.
Vous pouvez évidemment partager vos victoires sur vos réseaux sociaux préférés 😉

Vous recevez un mail sur certaines actions et certains succès, tout est fait pour vous encourager dans l’utilisation de la plateforme.

Page de profil, ou y trouve les points, les bagdes et la progression

Page de profil, ou y trouve les points, les badges et la progression

 

Quand l’élève devient maître

Vous pouvez participer à l’évolution de la plateforme en proposant vos propres cours. Je n’ai malheureusement pas expérimenté cette partie. Il semble que vous pouvez vous créer une certaine réputation en proposant des cours de qualité.

Conclusion

Cette plateforme permet de partager et d’évoluer aussi bien en tant qu’élève qu’en tant que professeur. Le cours de JS est une bonne introduction et l’interface permet d’essayer rapidement son code. Mon seul bémol concerne la traduction très partielle et de qualité variable suivant la langue choisie. Si vous débutez dans une des technologies proposées ou que vous voulez revoir les bases, n’hésitez pas à vous inscrire et essayer ce service.

Brackets, l’éditeur web expérimental à expérimenter !

Profile

logo de l'éditeur Brackets

Découverte

C’est lors d’une discussion qu’on me conseilla Brackets (merci Sylvain). C’est un éditeur Cross plateforme, simple, gratuit avec une communauté active, fait par et pour des développeurs web.

Made with ♥ and JavaScript

Je le télécharge, l’installe, et…. ça ne fait pas tout ce qu’on m’a promis! Point d’inquiétude cependant car mon conseilleur me dit : « ça marche avec un système d’extensions, je vais te filer les miennes ». OK, en fait les extensions se trouvent et se téléchargent directement depuis l’éditeur.

capture de l'écran de gestion des extensions 

Utilisation

Extensions

Je vous donne une petite liste d’extensions que j’utilise :

  • Annotate : génération d’annotations de jsdoc
  • Beautify : format JS, HTML& CSS
  • Brackets Key Remapper : permet de modifier le mapping des raccourcis
  • Brackets Snippets : une extension pour créer et utiliser des snippets
  • brackets-code-folding : extension pour avoir du code folding
  • Display Shortcuts : montre les raccourcis en bas de l’écran
  • Interactive Linter : remonte les erreurs à partir de JSHint/JSLint/CoffeeLint en temps réel
  • HTMLHint : support htmlLint
  • Jade : support de jade.js
  • Reload in Browser : pour recharger le browser avec un raccourci clavier
  • Simple JS Code Hints : support un peu moins contraignant que le JSLint d’origine
  • Themes for Brackets : fourni une liste de thèmes pour personnaliser l’éditeur
  • Theseus for Brackets : debugging JS dans Chrome pour Node.js
  • Todo : gestion des todo du projet
  • Various improvements : tout est dans le nom

Les mises à jours sont régulières et sont en évidence dans le gestionnaire d’extensions.
J’ai eu un problème avec l’extension des thèmes, il suffit de recharger Brackets (F5 ou Deboguer>Recharger Brackets)
Le linter JS interactif est parfois capricieux, la plupart du temps, il suffit de sauvegarder et de formater le code (ctrl+alt+l).
Il existe bien d’autres extensions, je ne vous ai pas listé toutes celles que je teste, mais je vous laisse le plaisir de la découverte.

Sur un projet

Capture d'écran de barckets sur un fichier app.js (node.js)

J’ai découvert Brackets en créant mon premier projet Node.js.
Avec les extensions et une console, c’est plutôt confortable.
On peut ouvrir un dossier représentant le projet et l’arborescence est accessible dans un volet.
Les code linters interactifs permettent de limiter les problèmes syntaxiques.
Le formatage et la coloration syntaxique sont plus que correct.
J’ai regretté l’impossibilité de splitter la fenêtre, finalement je lance plusieurs instances de Brackets.

Capture d'écran d'édition de css avec Brackets
J’ai été un peu déçu par par Theseus qui ne propose pas une exploration des objets en profondeur, mais je vous en reparlerai dans un article ultérieur.

Il y a quand même pas mal d’instabilité mais comme les technos sont récentes et les mises à jours très régulières, c’est tout à fait normal et supportable.

Conclusion

Les moins

  • L’instabilité des extensions. C’est l’apanage de la jeunesse.
  • Le foisonnement d’extensions peut perdre un peu le néophyte (que je suis).
  • L’état BETA. Il manque des choses basiques comme le split d’écran.
  • La politique d’Adobe. On a vu comment ont fini certains projets, on peut légitimement se demander ce qu’ils vont faire de cet éditeur

Les plus

  • L’esprit. On voit la même inspiration que pour Sublime Text
  • L’ouverture. On peut suivre les évolutions, partager nos remarques, participer au développement
  • La communauté vraiment active, des mises à jours régulières et des extensions bien pensées
  • La mise à jour en live du navigateur sur les modifications dans l’éditeur
  • Les aides d’éditions (choix des couleurs, modification des CSS etc..)
  • Les interactions éditeur/Chrome (affichage en live des appels de méthode d’un serveur node avec Theseus)

En bref

Brackets est un éditeur vraiment prometteur. Si cet esprit reste et que la gestion produit est bonne, on aura certainement un des meilleurs éditeurs du marché. La seule ombre au tableau est le doute quand à la politique d’Adobe. Je vous encourage vivement à le tester si vous bossez sur du JS, HTML et CSS.

Il est ou ton environnement de travail ? Dans ton cloud!

Dans de précédents articles (IDE rails la suiteAptana, finalement pas) , nous avons abordé différents IDE pour faire du développement rails sous Windows. Le choix d’outils en fonction de l’environnement est incontournable pour tout développeur. L’installation de l’IDE et la configuration de votre environnement n’est plus une fatalité, il existe une alternative: le cloud !

Je vous propose de découvrir deux outils  Koding et Cloud9 IDE online. Ce sont tous deux des environnements de développement intégrés utilisables directement dans votre navigateur favori.

Koding

C’est une plateforme de développement orientée réseau social. Quand vous vous connectez, vous tombez sur l’activité de tous les usagers. Sachant qu’à l’heure ou j’écris cet article, il y a 44 144 utilisateurs (d’après leur page membres), ça pollue passablement votre flux. Mais n’ayez crainte, vous pouvez configurer tout ça.

Coté développement, il y a de quoi s’amuser un peu. Il s’agit d’une VM avec un CentOS et des éléments de base: un terminal pour manipuler la vm, un éditeur de texte avec une coloration syntaxique et quelques applications.

J’ai testé un créateur de projet rails qui semble fonctionner sans problème. J’avoue avoir été un peu perdu une fois le projet créé, j’ai cherché comment l’utiliser car le viewer ne le permet pas.  Après plusieurs tentatives infructueuses et un peu de googling, je suis tombé sur la marche à suivre : http://kwiki.koding.com/wiki/RoR. Bon c’est un peu basique mais ça fonctionne ;). J’ai également récupéré mes projets depuis mon compte github sans aucun soucis.

Conclusion

Le message est clair, c’est une beta avec pas mal de « coming soon », de choses assez basiques  et de plantages réguliers (ralentissements, impossibilité d’utiliser la console). Cependant, on peut s’en sortir avec quelques recherches sur google et la lecture des documents proposés par les utilisateurs. L’orientation application  à la façon market encourage la communauté dans l’amélioration des services de la plateforme. On peut toutefois se demander sous quelle forme ce service sera monétisé et dans quelle mesure on pourra utiliser son compte « gratuit ».

Cloud9

Plus ancien, il est aussi plus abouti et bien documenté. La version gratuite permet une utilisation « basique » avec des espaces de travail publiques et alloue un espace de 123M. La version payante (12$/mois) permet, entre autre, 6 espaces privés, votre propre VM et un nombre illimité de collaborateurs. Pour mon test, je me suis connecté sur mon compte github et j’ai récupérer quelques projets. Pour le projet rails, j’ai suivi cette documentation. L’utilisation m’a parue plus simple que Koding et l’environnement moins « fouillis ». On comprend rapidement comment lancer son application.

Conclusion

Cloud9 propose un environnement efficace et clair. Il est plus mature, possède également une formule payante plus complète. Je n’ai pas eu de soucis particulier, ces quelques heures d’utilisation m’ont convaincue. Je pense continuer dans mon exploration, voir développer un ou deux petits projets avec, histoire d’en voir un peu plus. La version gratuite me suffit car je n’ai que peu de projets et ils sont tous open-source. Un passage à la version payante se justifierait avec un projet non open source ou des besoins plus importants (plus d’informations).

Le mot de la fin

A mon sens, Koding est clairement plus orienté plateforme communautaire alors que Cloud9 propose un environnement développement pur et dur. Les deux permettent de développer une application en gardant un œil sur le résultat et une console ouverte pour l’exécution des commandes et autres scripts.

Dans les deux cas, l’avantage de ne pas avoir à installer son environnement de travail est incontestable  Vous pouvez développer de n’importe où, il vous suffit d’un navigateur. L’inconvénient est bien-sur le besoin d’une connexion internet et l’ouverture vers l’extérieur qui peut soulever des problèmes de sécurité.

N’hésitez pas à partager vos expériences sur ces outils ou d’autres environnements. Il me reste deux invitations pour Koding si ça tente quelqu’un 😉

@bientôt

Code and coffee à Toulouse – découverte

Code and coffee, le concept

Une idée toute simple circule sur le net, le code and coffee. Concrètement, c’est juste un prétexte pour que les gens se croisent et discutent. On s’installe dans un café ou n’importe quel espace qui permet de partager, coder, twitter etc…

Sur Toulouse, l’initiative est partie de @avernois avec un article sur son blog et d’un peu d’activité sur twitter.

Mes impressions

Vraiment Sympa!

Et surprise, je retombe que sur les mêmes visages qu’a Sudweb. C’est bon enfant, on peut aborder n’importe quel sujet, qu’il soit technique ou non. Ca permet aussi de trouver des gens qui font du ruby ;), de partager ses expériences et de se détendre avant une rude journée. Si je ne me trompe pas, j’ai pu croiser @dplaindoux @hilldude @joelazemar  et @AntoineCezar

Le mot de la fin

C’est un bonne expérience malgré le réveil un peu difficile. Finalement, nous étions un peu plus dans le #tweetandcoffee, voir le #tweetandtea ;). Je pense que ça vaut le coup d’y aller au moins une fois de temps en temps pour échanger avec des gens de tous horizons, améliorer son réseau ou tout simplement passer un bon moment.

@+

 

 

La naissance de Pibou – préambule

Je vous propose un voyage à travers des technologies web, des outils, et un écosystème luxuriant. Point de vérité absolue ou de solution ultime en vue, mais du partage et de la découverte.

Le besoin

Qui dit application dit réponse à un besoin. Disons un outil de gestion pour votre collection de dvd/blu-ray.

Quelles technologies ?

Il s’agit d’une application CRUD classique, nous allons en profiter pour utiliser un framework de « haute productivité ». Nous pourrions choisir Play!, SpringRoo ou Grails mais nous allons nous pencher sur Ruby On Rails. Nous allons partager notre travail avec Git sur GitHub et nous déploierons l’application sur Heroku.

Nous croiserons la faune et la flore de cet écosystème au fur et à mesure de nos besoins et de nos envies. Parmi les espèces que nous pourrions rencontrer : RVM, JS, CoffeScriptLESS ou Sass , Bootstrap from twitter, devise et bien d’autres encore…

Préparation des bagages

Pour partir sur la route avec Ruby On Rails, on peut faire une petite préparation avec quelques excursions de mise en bouche :

Ya plus qu’a…

Ces quelques bagages en poche, nous partons pour la réalisation de notre gestionnaire de dvd. Nous pouvons nous projeter dans les fonctionnalités et voir où le vent nous portera.

Ah oui, j’oubliais, Pibou sera le nom du projet 😉 @très bientôt.

SVN tu l’aimes ou tu prends GIT!

Tout développeur qui se respecte utilise un outil de gestion de sources. Si vous me dites que vous envoyez encore des archives par mail, je ne peux plus rien pour vous…

De quoi parle-t-on ?

Plaçons le contexte, SubVersioN (2000) fut créé pour remplacer CVS (1989) et reste utilisé dans de nombreux projets. Quant à GIT (2005), que dire ? Rapide, puissant, efficace. Ok, j’en fais un peu trop. Pour vous faire une idée plus précise sur le fonctionnement et l’utilisation de GIT, je vous invite à regarder une excellente présentation réalisée par Sébastien Douche (partie 1, partie 2).

Au début, tu as peur de GIT

  • les commandes à apprendre/comprendre
  • la gestion locale/distante
  • mal utiliser sa puissance (ex: suppression sur tout l’historique)
  • la compréhension topologie vs timeline

Puis tu te rappelles de SVN

  • Pour enregistrer ton travail, tu es obligé de l’envoyer sur le serveur
  • Tu as peur de faire des branches (surtout pour le merge en fait)
  • Si tu copies/colles un dossier et tu te lamentes
  • Tu as des .svn dans tous les dossiers

Et là, tu t’amouraches de GIT

  • merge hyper efficace et paramétrable (plusieurs algo sont disponibles)
  • Un renommage de fichier, si vous l’avez déjà pratiqué avec svn, vous savez de quoi je parle 😉
  • Pas de .svnquisefoupartout
  • La logique qui vous permet de mieux structurer votre code (création et utilisation des branches & Tag)
  • Grande liberté de manipulation
  • La rapidité d’utilisation (on se demande parfois s’il s’est passé quelque chose)

Le mot de la fin

J’ai aimé SVN comme un premier amour, la lumière après les ténèbres mais notre histoire est finie.

La puissance et le confort de GIT en font une arme redoutable. Si vous prenez la peine de passer vos a priori et le début de la courbe d’apprentissage, vous ne pourrez plus vous en passer.

Et vous, êtes-vous GIT ?