Tig est un client git en ligne de commande

Il n’est pas compliqué à installer :

1

sudo apt-get install tig

Néanmoins c’est la version 1.2 dans les dépôts au moment ou j’écris ces lignes.

On peut installer la version 2 qui a plus de fonctionnalités et de raccourcis.

1
2
3

git clone https://github.com/jonas/tig
make
make install

attention vous aurez probablement besoin d’avoir installer la librairies libncursesw pour l’utf-8

La vue principale

Elle permet de voir l’historique du dépôt.

Nous allons repartir sur la SPL.

Je vais parler des différentes méthodes amusantes à surcharger.

Count

Soit la classe suivante

1
2
3
4
5
6
7
8
9

class BadCounter implements countable{
    public function count() {
        return 42;
    }
}

$counter = new BadCounter();

var_dump(count($counter));// int(42)

J’utilise souvent le programme htop. mais il y en a d’autre.

atop

Plus austère. Beaucoup d’information sur toutes les ressources. C’est plus un outils d’audit. Le logicel donne toutes informations possibles. processeurs, disques, carte réseau. En pratique il peut même être lancer au démarrage. En pratique on parle de sar (System Activity Report). Il permet de surveiller la tailles des processus avec la colonne VGROW (Virtual Memory Grow) et RGROW(Resident memory Grow)

voir sar

vtop

Un clone en Nodejs. voir le screenshot c’est vraiment très joli

installation via npm

1

sudo npm install -g vtop

dépot Github

Nous continuons sur les promises et le yield.

• partie 1 les promises
• partie 2 le Yield
• partie 3 les co-routines

Je vais parler de Guzzle qui est un client HTTP. Nous allons voir la version 6 qui utilise Php5.5

Promise et Guzzle.

Guzzle connait les promises et possède sa propre implémentation.

la signature de la fonction est un peu près la même que react/promise.

Attention Guzzle ne fait pas la différence entre le Deferred qui est un travail dont la réponse est encore inconnu et représenter par une promise. Dans Guzzle le travail et la réponse sont la même chose.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

use GuzzleHttp\Promise\Promise;

$promise = new Promise();
$promise->then(
    // $onFulfilled
    function ($value) {
        echo 'Tout va bien.';
    },
    // $onRejected
    function ($reason) {
        echo 'On a un problème.';
    }
);

$promise->resolve(null); // 'Tout va bien.';
// Ou 
$promise->reject(null); // 'On a un problème.';

Nous allons continuer sur le yield partie1

Nous avons vu la fonction xrange qui permet de générer un million de valeurs pour un coup très faible en mémoire.

Mais il y a mieux ! On peux envoyer des valeurs dans le générateur

1
2
3
4
5
6
7
8
9
10
11
12
13

<?php
function generateAnimal() {
    $input = (yield 'Panda');
    var_dump("j'ai reçu $input");
    $input = (yield 'Lama');
    var_dump("j'ai reçu $input");
}

$gen = generateAnimal();
var_dump($gen->current());// string(5) "Panda"
var_dump($gen->send('Canard'));//string(16) "j'ai recu Canard"
                               //string(4) "Lama"
var_dump($gen->send('Poney')); // j'ai recus Poney.

Si j’avais fais deux fois ->next() au lieux de ->send()

1
2
3
4
5

$gen = generateAnimal();
var_dump($gen->current());// string(5) "Panda"
var_dump($gen->next());//string(16) "j'ai recu NULL"
                               //string(4) "Lama"
var_dump($gen->next()); // j'ai recus NULL.

Aujourd’hui je vais parler des problèmes Np-complets avec le xkcd suivant. L’original est ici

On appelle ce genre de problème les NP-complets

Pour faire simple (Ce que j’en ai compris)

Les NP-problèmes sont des problèmes donc il est très facile de vérifier une solutions. Dans notre cas ici il suffit de commander 7 * 2.15 pour obtenir 15.05. Le problème a une solution. Mais il est quasiment impossible de trouver une méthode efficace pour déterminer la solution, voir même de savoir s’il y a une solutions.

Nous allons voir une nouveauté de PHP 5.5 l’instruction yield

Cela permet de mettre en place ce qu’on appelle les générateurs.

Un premier exemple

Regardons un exemple ensemble

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

<?php
function generateAnimal() {
    echo "Je suis dans le générateur\n";
    yield "Panda";
    echo "Je suis retourné dans le générateur\n";
    yield "Lama";
    echo "je suis de retour\n";
    yield "Alpaga";
    echo "plus de d'animaux\n";
}

$generator = generateAnimal();
foreach ($generator as $value) {
    echo "j'ai reçu $value \n";
}

Voici le résultat

1
2
3
4
5
6

j'ai reçu Panda 
Je suis retourné dans le générateur
j'ai reçu Lama
je suis de retour
j'ai reçu Alpaga 
plus de d'animaux

D’abord un générateur se comporte comme un iterator. C’est grâce à cela que je peux faire un foreach.

Je vais refaire pas à pas avec des commentaires.

Les promises sont une alternative plus puissante au Callback. Relativement peu connues au début. Elle sont maintenant en standard dans beaucoup de langage javascript ES6, python 3.2, java. Où via des librairies comme react/promise pour php

Une promise représente une valeur donc le résultat n’est pas encore connu. Quand le résultat est connu, la promise a 3 états possibles

• Pending ou Unfulfillled en Attente..
• Resolved ou fulfillled Succès
• Rejected ou Failed Erreur.

Un Deffered représente un travail qui n’est pas encore fini. Donc un Deferred possède une promise (une valeur pas encore connues).

Quand la valeur est connue, la promesse utilise un handler (en général ->then()) qui lui-même renvoie une promise. L’intérêt est que les promises sont chainables.

Mais essayons quelques exemples qui seront un peu plus parlant.

Pour ce faire nous allons d’abord installer react/promises

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

<?php
require __DIR__.'/vendor/autoload.php';

// On crée un travail
$deferred = new React\Promise\Deferred();

// On veux la promise
$promise  = $deferred->promise()->then(
    function () { echo "tout va bien \n"; },
    function () { echo "tout va mal \n"; },
    function () { echo "j'attends\n "; }
);


// Le travail est un succes, on résoud la promise
$deferred->resolve();

Voici ce que j’obtiens si je lance le programme.

1

tout va bien

Si je remplace $deferred->resolve() par $deferred->reject(). Le travail n’as pas marché. J’obtiens

1

Tout va mal

Soit le fichier texte suivant:

1
2
3
4
5
6

 * Alpha
 * Foxtrot
 * Charlie
 * Delta
 * Echo 
 * Bravo

Dans VIM il suffit de taper.

1

:%sort ou :%!sort

Pour obtenir

1
2
3
4
5
6

 * Alpha
 * Bravo
 * Charlie
 * Delta
 * Echo 
 * Foxtrot

Introduction

Je vais parler de SplStack une structure de donnée qui fait partie de La SPL (pour Standart PHP Librairie). Nous allons voir trois façons de nous servir de cette structure.

Les Stacks ou Piles

La pile n’a que deux opérations.

• Empiler ou Push On ajoute une donnée sur le haut de la pile.
• Dépiler ou Pop On retire une donnée du haut de la pile.

Il n’y a que le haut de la pile qui est visible. La pile est une mémoire LIFO (Last In First Out).

Quelques exemples.

1
2
3
4
5
6

$pile = new SplStack(); // la pile est vide []
$pile->push(34) // [34]
$pile->push(45) // [34, 45]
$value = $pile->pop() // [34]
$pile->push('a') // [34, 'a']
$value = $pile->top() // $value = 'a' pile [34, 'a']