Non, ce n’est pas la couleur de votre peau, ni celle de votre chemise. C’est plutôt la couleur métaphorique de votre cerveau, qui permet de determiner votre profil individuel, ou de votre équipe. Ce profil est developpe par Ned Herrmann est en fait un outil de connaissance de soi visant à identifier les modes préférentiels de traitement de l’information des individus.

Herrmann divise le traitement des informations en 4 modes principales. L’hemisphere gauche du cerveau, designé comme « Raison et Methode » est representé par deux modes (A. Analytique et B. Raison), tandisque l’hemisphere droit « Sentiment et Imagination » est representeé en deux modes D. Visionnaire et C. Humain.

1. Le Mode de pensée Analytique

Le mode de pensée Bleu represente une personne Logique, Factuelle, Critique, Technique et Quantitative. Cette personne compile les faits, analyse et argumente, raisonne et travaille a partir de chiffres précis.

2. Le Mode de pensée Sequentielle (Raison)

Les personnes vertes sont des personnes structurées, organisées, detaillées et planifiées. Elles remarquent les defauts et ont une approche pratique des problèmes. Elles vont jusqu’au bout des choses et developpent des plans détaillées. Ce sont des personnent qui envisagent les problèmes en terme de Planning.

3. Le Mode de pensée Humain

Ces personnes, représentées par la couleur Rouge, sont des personnes émotionnelles et sensibles, mais aussi Spirituelles et qui ont de l’empathie. Elles comprennent les comprend les difficultés relationnelles et anticipent souvent le ressenti des autres. Elles perçoivent des éléments non verbaux issus du stress. Ces personnes sont persuasifs, concilient et enseignent, mais aussi prennent en compte les valeurs et comprennent les éléments émotionnels.

4. Le Mode de pensée Imaginatif et Visionnaire

Si vous êtes jaune, vous êtes probablement Intuitif, intégratif, synthétique et conceptuel. Vous avez donc une vue globale des choses et vous tolérez l’ambiguité. Vous intégrez les idées et les concepts et défiez les regles établies. Vous avez le talent d’inventer de nouvelles solutions et vous résolvez les problèmes de manière intuitive.

Et si vous étiez multicolore ?

En effet, ce ne sont pas toutes les personnes qui ont une seule couleur, bien au contraire. Selon les statistiques:

• 7% des gens ont une seule couleur
• 60% ont 2 couleurs
• 30% ont 3 couleurs
• 3% sont équilibrés

Essayez l’exercice et vous verrez que vous êtes probablement dans les 60%

Maintenant, pourquoi parle-t-on de tout ca? La réponse est dans la premiere partie du titre de ce post : « Communication ». En effet, connaitre le profil de votre destinataire :les membres de votre equipe, votre public, votre boss etc. vous permet d’avoir une communication « efficace ».

Quand vous parlez par exemple a des financiers (des bleus ), vous n’allez certainement pas argumenter en vous focalisant sur la « vision » et donner des images abstraites, mais au contraire, arriver avec des chiffres exacts et des données et des graphiques.

Si vous présentez plutôt un concept a votre Votre Lead de departement Design,  vous allez plutôt donner une vue « enthousiaste » et ensembliste.

Ou encore, si vous parlez a une Personne « Humaine » en annonçant votre projet, vous allez presenter la chaleur positive de ce projet sur les individus et souligner la façon dont ca aidera les autres.

Quelques astuces pour passer un bon message

si vous vous adressez à une personne :

• Analytique
  • Fournir des données 
  • Appuyer avec des preuves (Etudes ou graphiques)
  • Avoir une approche logique
  • Maitriser le sujet
• Humaine
  • Manifester de l’ouverture 
  • Souligner l’impact positif sur les autres
  • Favoriser la discussion, l’interaction et le travail en groupe
• Realiste
  • donner des points clés
  • Enoncer les benefices et les couts
  • Presenter les étapes suivantes
  • Utiliser des listes
  • Etre logique et concis
• Visionnaire
  • Donner une vue d’ensemble
  • Souligner les défis
  • Etre enthousiaste
  • utiliser des images

Affichez votre couleur au travail

Un exercice que vous pourrez faire pour favoriser la communication, est d’afficher votre couleur. Faites l’exercice et determiner votre (vos) couleur(s), et Affichez la (les) sur votre bureaux. L’exercice est valable aussi au niveau de votre equipe. Croyez moi, ceci sauvera pas mal d’heures de d’obstination

Toutefois, il existe des actions que les deux parties prenantes (employé et gestionnaire) peuvent faire pour gérer ces situations, et c’est le sujet de ce post.

Il existe 7 phases de préoccupation concernant le changement, durant ces phases, les responsabilités du gestionnaire et de l’employé se détaillent comme suit :

Phase 1 : L’immobilité, la continuité des projets habituels et le manque d’importance accordée au changement.

Lors de cette phase, l’expression courante est du genre « Je doute que ce changement m’affecte ». Dans ce cas, le Gestionnaire doit communiquer de façon précise et donner de l’importance au changement annoncé, Tandis que l’employé doit plutôt confronter sa position a celle des autres et se poser des questions et le mieux, rechercher des faits et des données vérifiables et ne pas être subjectif.

Phase 2 : L’inquiétude et l’insécurité

L’employé commence a s’inquiéter, le changement pourrait avoir un impact sur son travail (perte d’emploi, de patron, de collègues , mais aussi une perte de pouvoir ou de competences, un changement des outils de travail ou de l’organisation de travail. L’expression clé est : « Que va t’il m’arriver? »

Dans cette phase, le role du gestionnaire est crutial pour écouter  mais surtout pour soutenir l’employé. L’employé doit exprimer ses inquietudes aux bonnes personnes pour chercher les bonnes réponses  L’employeé doit aussi accepter que l’information ne soit pas disponible.

Phase 3 : Légitimité et pérennité du changement

Dans cette phase, l’employé se pose la question « Est ce que le changement est la pour durer? ». Il est inquiet quand aux consequences organisationnelles du changement a moyen et long terme, et se questionne surtout sur la légitimité et la capacite de l’entreprise de mener a terme le changement.

Le gestionnaire doit ici démontrer le sérieux et les raisons du changement et illustrer les moyens engages par l’entreprise pour la réussite du changement. L’employé quand à lui, doit comprendre les raisons qui motivent le changement et se positionner par rapport a ceci, entre autre la question qu’il devrait s’investir ou plutôt rester passif.

Phase 4 : Scénario et mise en oeuvre du changement

L’employé se questionne sur la qualité de la mise en oeuvre du changement, aux ressources et efforts alloués, et s’inquiete quand au scenario de déroulement de ce dernier. « Que signifie ce changement? » et « Comment fait-on? » sont généralement les expressions qui se posent dans cette phase.

Le gestionnaire doit communiquer le plan d’action et les ressources allouées pour ce changement, et faire participer l’employé. L’employeé doit répondre aux questions Qui, Quand, Comment, Avec qui et échanger avec d’autres personnes ayant eu le meme type de changement.

Phase 5 : Capacité de faire face au changement

L’employé se demande quand à sa capacité de faire face aux changement ainsi qu’au soutien et la comprehension de son superieur. La question qu’il se pose est « Est ce que je vais être capable de … ».

Dans ce cas, le gestionnaire doit faciliter le transfert des nouveaux acquis, travailler sur l’accompagnement et le temps d’adaptation avec l’employé. Ce dernier doit clarifier les attentes de son gestionnaire, et exprimer ses besoins spécifiques sur le plan technique, afin de réduire ses zones d’inconfort.

Phase 6 : échange et collaboration

L’employé se préoccupe par rapport aux occasions de collaboration avec les autres equipes ou service, ainsi que les occasions d’échange. L’expression clé est « Comment l’ensemble des concernés peuvent collaborer? ».  Dans cette phase, le gestionnaire devrait faciliter l’échange entre les différents destinataires et apprendre du changement. L’employé peut s’impliquer dans les comité afin de mettre a profit ses connaissances.

Phase 7 : Amélioration

« Comment pouvons nous faire mieux? », c’est ce qui préoccupe l’employé dans cette phase, ce dernier cherche a s’améliorer continuellement. Le gestionnaire doit être ouvert pour laisser les pistes de solution émerger des employés et équipes. L’employé doit innover, oser et agir.

Conclusion

Lors de ces 7 phases, les roles de Gestionnaire et d’employeé doivent se completer pour mener a terme et réussir le changement. Les reactions et les efforts de chacun des deux parties sont cruciaux pour une réussite du changement.

La courbe de changement

Il existe en fait ce qu’on appelle « la Courbe de changement ». Cette courbe détaille les differentes reactions émotives dans le temps, suite a l’annonce d’un changement.

La courbe de changement

1. La stabilité: Dans ce stade, l’employé est dans un état stable, il maitrise généralement son travail, possède des habitudes, mais surtout une maitrise et une expertise dans ce qu’il fait.
2. La confusion : Le changement est annoncé, par exemple, un changement de poste, de technologie ( utiliser un nouvel, un nouveau langage de programmation , une nouvelle methodologie de travail etc.). L’employé est immobile à ce stade, et ne croit pas encore a la nouvelle annonce.
3. Le rejet : L’employé essaye systématiquement de défendre l’ancienne façon de faire et rejette la nouvelle.
4. L’agressivité : Passant par un sentiment d’amertume, et parfois de colère, l’employé peut devenir agressif.
5. La négociation : L’employé tente par la suite de négocier pour minimiser les impacts sur sa situation actuelle.
6. La frustration : L’employé passe par un sentiment de frustration, puisque la négociation ne donne pas de resultats.
7. Le test : L’employé essayé la nouvelle solution (techno, language etc.) de façon limitée.
8. L’acceptation : L’employé accepte le changement, mais toujours avec une perception negative.
9. L’engagement : L’employé perçoit les avantages du changement, et agit positivement.

Maintenant, Sérieusement, essayez d’appliquer ces états durant votre journée, que ce soit sur des scenarios microscopiques (par exemple quand vous voulez instaurer un nouveau pattern de programmation avec un collègue, ou encore quand vous demandez à votre enfant de ranger sa chambre . Ca marche!

Les 4C et les préoccupation contre le changement

Mais pourquoi le changement derange t’il les gens?
Le changement perturbe car:

1. Il oblige les gens à laisser leur zone de CONFORT ou une situation à laquelle ils étaient habitués.
2. Il fait perdre la CONFIANCE que des individus avaient en leur moyen, ou envers des autres.
3. Il fait douter les gens de leurs COMPETENCES ou il les force a en avoir de nouvelles.
4. Il risque de faire perdre le pouvoir et la reconnaissance, et donc le CONTROLE que les employees avaient dans leur fonction.

Mais il existe des solutions pour gérer ces préoccupations. ce que j’expliquerai dans un prochain article sur la gestion de Changement.

En Général, un itérateur n’est rien d’autre qu’un générateur de séquence.

A la base, une séquence est une liste ordonnée de valeurs. Ces valeurs peuvent être répétées dans la liste plusieurs fois, et il n’est pas nécessaire qu’elle soient ordonnées.

Le type le plus basique de séquence en programmation est le tableau. Les éléments d’un tableau peuvent avoir de n’importe quelle valeur, et peuvent etre positionnees arbitrairement. Toutefois, une fois ils sont placées, le tableau a un ordre défini.

Si on parcoure ce tableau, chaque boucle aura l’élément prochain dans la séquence, jusqu’à ce que l’on arrive à la fin de ces éléments.

    foreach ($array as $key => $value) {
        echo $value;
    }

Si nous aurions parcouru ce tableau manuellement, nous aurions écrit une boucle for :

    for ($i = 0; $i < count($array); $i++) {
        echo $array[$i];
    }

A la première itération, la valeur de $i est 0,
On teste ensuite si $i est inferieure à la taille du tableau.
On execute par la suite le corps de la boucle.
Finalement, on incremente $i, et on retourne à l’itération 2.

Sans le réaliser, chaque fois que vous écrivez une boucle for comme ceci, vous construisez un itérateur.

Un itérateur n’est rien que l’abstraction de la boucle for.
Nous avons une méthode « rewind() », qui est la même chose qu’initiaiser $i a 0
Nous avons une méthode « valid() », qui joue le même rôle que le test si $i est inférieure à la taille du tableau.
Nous avons une méthode « next() » qui est la même chose qu’incrèmenter $i.
Et finalement, nous avons deux fonctions qui sont utiles dans le corps de la boucle :
la méthode « key() », qui joue le role de recuperer la valeur de $i.
et la méthode « current() » qui recupere la valeur de l’élément a l’index $i.

Donc, si on réécrivait notre boucle avec les itérateurs, ca ressemblerait à quelque chose du genre :

    for ($it->rewind(); $it->valid(); $it->next()) {
        $current = $it->current();
        echo $current;
    }

En réalité, c’est tout ce que la boucle « foreach » fait à l’interne! À l’exception que foreach expose $key et $value automatiquement pour nous.
Donc, notre code original de foreach devient :

    foreach ($it as $key => $value) {
        echo $value;
    }

Notez bien qu’il est presque identique que le premier foreach!
Lorsqu’on utilise foreach, les tableaux et les itérateurs sont interchangeables.

Construisons donc notre premier vrai itérateur. Construisons notre boucle for comme un itérateur :

    class ForLoopIterator implements Iterator {
        protected $array;
        protected $i = 0;
        public function __construct(array $array) {
            $this->array = $array;
        }
        public function rewind() {
            $this->i = 0;
        }
        public function valid() {
            return isset($this->array[$this->i]);
        }
        public function next() {
            $this->i++;
        }
        public function key() {
            return $this->i;
        }
        public function current() {
            return $this->array[$this->i];
        }
    }

Premièrement, Notre classe doit implémenter l’interface Iterator. Cette interface définit les 5 méthodes que nous avons besoin. Mais aussi, elle offre une logique (implémentée dans le langage) qui nous permet d’utiliser l’itérateur dans les construits foreach.

A part ça, cette classe ressemblerait à une facon plus expressive d’une boucle for.

Il est important aussi de noter qu’en pratique, nous n’allons pas écrire cette classe. Nous allons plutôt utiliser la classe core ArrayIterator qui fait essentiellement la même chose.

Donc, maintenant que nous avons notre concept d’itérateur basique, nous pouvons voir comment l’utiliser.

L’un des bénéfices d’utiliser un itérateur est qu’on peut optimiser l’utilisation de memoire en generant uniquement les valeurs dont on a besoin, lorsqu’elles sont necessaires.

Par exemple, essayons de generer une séquence Fibonacci.

    class Fib implements Iterator {
        protected $a = 0;
        protected $b = 1;
        protected $i = 0;
        public function rewind() {
            $this->a = 0;
            $this->b = 1;
            $this->i = 0;
        }
        public function next() {
            $tmp = $this->b;
            $this->b = $this->a + $this->b;
            $this->a = $tmp;
            $this->i++;
        }
        public function valid() {
            return true;
        }
        public function key() {
            return $this->i;
        }
        public function current() {
            return $this->b;
        }
    }

Vous pouvez construire un itérateur qui va uniquement générer une valeur à chaque fois.
Le gros bénéfice est qu’on peut produire un nombre infini de valeurs, sans que la consommation mémoire augmente au fure et a mesure.

Un autre bénéfice d’utiliser un itérateur est que nous pouvons décorer ce dernier pour fournir des fonctionnalités additionnels.

Par exemple, si nous voulons itérer sur les valeurs paires sur le tableau precedent. Avec les tableaux, nous devons utiliser array_filter et donc dupliquer le tableau.
Par contre, avec les itérateurs, nous pouvons simplement utiliser la Classe core CallbackFilterIterator.

    $it = new CallbackFilterIterator($it, function($value) { return $value % 2 == 0; });

La partie cool ici est que la structure du tableau original n’est jamais changée ou dupliquée. L’Itérateur va uniquement utiliser la méthode next() sur l’itérateur core jusqu’à trouver la valeur voulue.

La librairie SPL de PHP contient un nombre interessant de ce type de décorateurs que vous pouvez utiliser pour optimiser le comportement de vos itérateurs.

Maintenant, vous avez peut etre remarqué que les itérateurs ne sont pas typiquement des petites classes, leur implementation est assez verbeuse.

Par ailleurs, vous pouvez donner le comportement « traversable » a votre classe dans une boucle foreach en implémentant IteratorAggregate :

    interface IteratorAggregate extends Traversable {
        public function getIterator();
    }

L’interface IteratorAggregate permet d’instancier un itérateur different de votre classe. Supposons que votre classe a un tableau que vous voulez boucler dessus.

Au lieu de construire un nouvel itérateur dans votre classe, il faut simplement implementer IteratorAggregate :

    class MyClass implements IteratorAggregate {
        protected $myArray = array();
        public function getIterator() {
            return new ArrayIterator($this->myArray);
        }
    }

Maintenant, nous pouvons utiliser une instance de notre classe dans un foreach!
Les itérateurs sont un concept tres puissant qui, si utilisé comme il faut, permettre d’avoir un code propre et flexible!

La video originale d’Anthony Ferrara (Anglais) : http://www.youtube.com/watch?v=tW6GcZjBc3E&feature=share&list=PLM-218uGSX3DQ3KsB5NJnuOqPqc5CW2kW

Query Translator est un outil Web gratuit qui traduit vos requetes SQL standard en requetes Mongo. Excellent outil pour apprendre les dessous du systeme de requetes Mongo ou pour les newbies de Mongo. Vous avez juste a ecrire vos requetes et il generera la chaine JSON Mongo relative.

site web : http://www.querymongo.com/

Cette semaine, c’est au tour de la notion d’injection de dependances d’être expliquée en vidéo dans les séries  « Programming with Anthony ».

Voici la traduction en Francais de cette explication.

et la video ci-bas

Qu’est ce que l’injection de dependances?
Litéralement, cela veut dire : injecter des des dependances.
Commençons par definir ce qu’est une dependance. Une dependance est en effet un objet que votre classe necessite pour fonctionner.
Si nous avons une classe modele qui recupere des données depuis un objet Database, nous pouvons dire que ce la classe modele a une dependance a l’objet Database.
Maintenant que nous savons ce qu’est une dependance, voyons ce que veut dire d’injecter des dependances.
Injecter des dependances veut juste dire que la dependance est poussée dans la classe depuis l’exterieur.

Tout ce que cela veut dire est que vous ne devez pas instancier vos dependances (avec le construit new) a l’interieur de vos classes, mais plutôt les récupérer comme un paramètre de constructeur ou un setter.

C’est tout ce que c’est par rapport a l’injection de dependances. Vous n’avez pas besoin d’un « container » super cool ou d’une classe pour faire de l’injection de dependances. C’est sur que votre vie sera meilleure si vous les utilisez, mais ils ne sont pas « necessaires ».

Mais pourquoi devons nous injecter des dependances ?

Let’s imagine for a minute that you’re programming a house building robot.
Imaginons que nous avons comme tache de programmer un robot de construction de maisons. Nous commençons par une pile de briques, et nous devons construire des murs. Nous arrivons par la suite a mettre la porte de notre maison. Que faisons nous dans ce cas? Est ce que nous construisons une porte a partir de matières premieres? ou que nous programmons notre robot pour récupérer une porte deja prete (qu’un autre fournisseur a construite) et nous ne faisons que l’installer?

La solution la plus flexible, évidemment, serait de récupérer la porte depuis un fournisseur externe.
Et c’est exactement ce que l’injection de dependances fait. Elle decouple la construction de vos classes de la construction de ses dependances.

La raison derriere cette importance est le principe d’Inversion de dependances.
Le principe d’inversion de dependances est le fait que le code doit dépendre d’abstractions. En dépendant d’abstractions, nous découplons nos implementations.
Ce que cela veut dire, c’est qu’en PHP, votre code doit dépendre d’interfaces. Vous pourrez alors substituer les differentes dependances, du moment qu’ils satisfont l’interface requise.
En utilisant l’injection de dependances, nous découplons le code de l’implementation bas-niveau, ce qui rend le code beaucoup plus elegant, plus facile a modifier et a réutiliser.

Maintenant que nous avons adopté l’injection de dependances, nous avons un autre problème. Chacune de nos classes necessite des dependances. Donc, pour construire chaque classe, nous devons trouver quels sont les dependances dont elles ont besoin et trouver un moyen pour récupérer ces derniers dans la ligne qui les instancie.

Heureusement qu’il ya une solution pour résoudre ce problème : Le conteneur d’injection de dependances, ou plus communèment connu sous « Dependency Injection Container ».

Au root de votre application, le container n’est rien d’autre qu’une « carte » des dependances que votre classe necessite, avec la logique necessaire pour les creer si elles ne sont pas encore créées.
A chaque fois que vous demandez une interface « DatabaseInterface », la carte des dependances indiquera quelle dependance utiliser, le container vérifie par la suite si l’objet a été instancié auparavant, et le réutilisé si c’est le cas. Sinon, il va creer l’instance Database, la sauvegarde et la fournit a votre classe.
Donc, au lieu de creer la classe par vous meme, vous demander au container de creer l’instance. Il va résoudre les dependances, construire l’objet et le retourner pour vous.

La meilleure partie est que le container peut résoudre des dependances complexes et c’est transparent! Si vous voulez changer la dependance pour une autre, ou par exemple la mocker dans un test unitaire, tout ce que vous avez a faire est de mettre a jour la dependance dans le container, c’est a une seule place.

Ecrivez donc un code plus propre et plus modulaire, utilisez l’injection de dependances.

La video

La première chose intéressante à propos des closures en JavaScript est qu’ils ne sont pas différents des fonctions normales. Toutes les fonctions JavaScript sont des fermetures.

Mais qu’est ce que les closures ? Simplement, une closure vient du mot anglais « close », qui veut dire « fermer ». Donc une closure ferme le contexte d’une fonction.

Cela signifie que le scope de la closure contient automatiquement toutes les informations de ses parents.

Pour comprendre ce que cela signifie, nous devons d’abord parler de le scope des variables.

Regardons un autre language : PHP.

PHP dispose de deux principaux scopes pour les variables : le scope Global et le scope de fonction.

le scope par défaut est toujours le scope de fonction (si on ignore les super globales).

Donc, si nous attribuons une variable de l’intérieur d’une fonction, cette variable sera définie uniquement dans le scope de la fonction.

Si l’on voulait que la variable soit plutôt dans le scope global, nous aurions besoin de déclarer notre intention avec le construit « global ».

Donc, en PHP, quand nous déclarons une closure, nous avons besoin d’indiquer explicitement les variables à importer à partir de le scope parente.

Ce qui est important a noter ici est que les variables sont imscopes. Les variables sont en fait copiées dans le scope de la closure.

Par ailleurs, dans PHP, chaque scope est complètement indépendant de n’importe quel autre scope. Le seul moyen de lier deux scopes et d’utiliser les references.

Javascript, Par contre, gere les scopes imbriquées. Les scopes s’imbriquent la ou elles sont definies.

Donc, si on definit une closure a l’interieur d’une fonction, le scope de la closure va etre imbriquee dans le scope de la fonction.

Ceci signifie que l’acces a la variable traverse la chaine des scopes parentes jusqu’a ce qu’il trouve le scope la ou la variable a ete definie.

Et du coup, toutes les fonctions qui ont ete definies dans les scopes des autres fonctions sont toujours des closures, meme si ils ont les noms de functions. Et en considerant que le scope racine est le scope global, toutes les fonctions sont imbriquees dans le scope global.

Et donc, toutes les fonctions dans Javascript sont automatiquement des closures!

Dans le cadre d’une serie de videos tres bien presentés, Anthony Ferrara Demystifie le fonctionnement des references en PHP. Bravo pour cette excellente explication.

Vous pouvez trouver ci-bas la traduction en Francais de cette superbe explication!

Pour explorer comment les références fonctionnent en PHP, dous devons d’abord prendre un peu de recul et jeter un oeil à la façon dont les variables fonctionnent en PHP.
Typiquement, on nous apprend à visualiser une variable un récipient pour une valeur nommée. Mais nous nous trouvons souvent dans une situation où nous avons besoin de copier une variable.

Les copies peuvent être aussi simples comme affecter une variable à l’autre. Mais les copies peuvent également se produire dans d’autres situations, tels que lors du passage d’une variable à une fonction,lors du retour d’une variable à partir d’une fonction
Ou lors de l’itération sur un tableau.

Alors, quand on copie une variable, on copie la valeur contenue aussi bien. Et cela fait sens. Si nous avons deux variables différentes avec des noms différents, nous nous attendons a avoir des conteneurs différents.

Donc, si nous éditons un conteneur, nous nous attendons que l’autre reste le même. Mais cela a des problèmes aussi, chaque fois que nous copions une variable, nous avons besoin de dupliquer la valeur contenue.

Cela peut conduire à une duplication grave de zones mémoire, ce qui peut entraîner des problèmes de performances.
PHP résout ce problème en séparant la variable du conteneur valeur. Les variables deviennent alors des pointeurs vers une valeur. Quand on copie une variable, nous copions tout simplement ce pointeur.
Cela introduit un nouveau problème: lorsque nous supprimons une variable, Comment pouvons-nous savoir si nous pouvons supprimer la valeur?

La façon dont PHP résout ce problème est de maintenir un comptage du nombre de références à une valeur. Ainsi, le conteneur valeur, dispose désormais de deux champs: La valeur elle-même,et un compteur de référence, aussi connu comme un « refcount ». Chaque fois que nous copier une variable, nous augmentons le refcount, et chaque fois que nous supprimons une variable, nous diminuons le refcount. Si le refcount arrive a 0, on peut sans risque supprimer la valeur.
Mais nous avons aussi un autre problème. Si nous modifions la copie d’une variable, nous faisons aussi éditer l’original puisqu’ils utilisent le conteneur même valeur.

Heureusement, nous avons déjà une façon de régler ce problème. Le « refcount » peut nous indiquer quand nous pouvons modifier ou quand nous avons besoin de copier la valeur.

Ainsi, lorsque nous éditons une valeur, si le refcount est 1, nous pouvons modifier directement la valeur.

Si le refcount est supérieur à 1, nous avons besoin de copier la première valeur, et puis, nous pouvons modifier la copie.

Ceci est également connu sous le nom « copy on write ».

Jusqu’ici tout va bien.

Maintenant, qu’est-ce qui se passe lorsque nous voulons deux variables pour pouvoir les éditer ensemble en même temps?
En PHP, nous allons utiliser l’opérateur de référence eperluette.

Mais qu’est ce qui est fait que sous le capot?
Eh bien, pour mettre en œuvre cette fonctionnalité, tout ce que nous devons faire est de désactiver la copie-sur-écriture.
Mais nous ne voulons le désactiver que pour les valeurs référencées.

La façon pour atteindre ce but est d’ajouter un champ supplémentaire dans le récipient valeur. Il s’agit d’une valeur booléenne simple, que nous appellerons « is_ref ».

Si is_ref est vrai alors que nous éditons un varible, nous ne copions pas la première valeur.

Mais maintenant qu’est ce qui se passe si nous essayons de faire une copie normale d’une valeur de référence?
Nous ne pouvons pas augmenter le refcount, car alors nous ferions une référence à la place.

Nous avons donc besoin de faire une copie complète de la valeur. Par conséquent, à chaque fois que nous utilisons des références,
Nous perdons tous les avantages que copy-on-write nous donne.
En PHP4, c’est ainsi que toutes les variables sont gerees.

A partir de PHP5, les objets sont traités d’une manière légèrement différente. Au lieu de stocker l’objet sur la meme valeur,
il ya une deuxième couche d’abstraction. Les objets sont stockés dans leur propre conteneur et pointés par la valeur.
Qu’est-ce que cela signifie pour nous, c’est que même si on copie une variable objet, tous les contrôles vont encore à la même place.
Donc, nous n’avons pas besoin d’utiliser des références variables du tout lorsqu’il s’agit d’objets.
Si nous voulons faire une copie d’une valeur de l’objet, nous avons besoin d’utiliser le « clone » de l’opérateur.

Lors de l’écriture moderne du code PHP, il ne faut donc pas essayer de déjouer le système.
L’utilisation de références pour tenter de sauver la mémoire finira en général par vous coûter plus de mémoire.
Laissez PHP manipuler des variables pour vous, Il est plus intelligent que vous le pensez.

La liste des sessions « Programming with Anthony »

Le blog de Anthony Ferrara

Derby MVC framework permet d’ecrire des applications collaboratifs en realtime, qui fonctionnent sur node.js ainsi que sur les navigateurs clients. Le framework offre un engin de synchronisation de donnees appelé Racer, qui synchronise automatiquement les donnees entre les navigateurs et les serveurs, ainsi qu’une base de donnees. Les modeles souscrivent a des objets specifiques, permettant ainsi le controle granulaire sur la propagation de donnees sans definir des canaux de transfert.

Racer permet l’utilisation offline et la resolution de conflits, ce qui offre un grand plus. Les applications Derby peuvent etre indexés par les moteurs de recherche puisque les templates s’affichent sur le serveur et le client. De plus, les templates definissent les « bindings », ce qui permet de mettre a jour instantanement la vue suite au changement de modele et vice-versa.

Requirements: Node.js Framework
Demo: http://derbyjs.com/
License: MIT License

Deployd est une platforme qui facilite la creation d’APIs REST. Avec Deployd, vous pouvez creer une API exploitable en quelques minutes! vous n’avez aucun serveur a installer, aucune configuration a faire.  faites simplement installer Deployd, et vous etes pret pour votre premiere API.

A part la creation de ressources via une interface graphique, Deployd expose aussi un objet Javascript du coté client, qui facilite l’inspection du code. le tout est sous license gratuite apache.

Nécessite : -
Demo: http://www.deployd.com/
License: Apache License