Utiliser l’api de recherche Bing

Cet article bien en complément du dernier où j’annonce avoir forké une lib permettant d’accéder simplement à l’API bing search.

Pour utiliser l’API de recherche Bing, il vous faudra obtenir l’autorisation de l’utiliser.

En effet, pour éviter que des abus de soient commis, Microsoft limite le nombre de requêtes opérables par mois sur son API, si vous en voulez plus, il faudra débourser.
La première étape consistera donc à se rendre sur cette page, et d’y sélectionner l’offre qui vous sied le mieux. Un compte Microsoft vous sera demandez, créez-le si vous n’en avez pas.

Continue reading

Interface simple d’accès à BingSearchAPI

Il y a une semaine environ, j’ai eu besoin de chercher une centaine d’image sur le web pour faire un POC d’une appli.

Alors, je me prépare à crawler le site du client. Seulement, dans ce monde javascriptisé, c’est la cata de faire un petit script bâteau qui repère juste les img src.

Alors, partons vers Google: inutile de crawler leur propre page web : elle est en chargement asynchrone. Et google, comme ce sont des gens bien ont décidé de déprécier leur API google search image. Je ne sais même pas si elle est encore opérationnelle.

“Alors”, me dis-je, “allons chez le concurrent direct, vive le marché libre !”.

Continue reading

PHP tableaux et data-structures

Cela fait plusieurs projets que je mène en PHP dans lesquels l’impact de mes choix de conteneur de données sont très importants. Basiquement, en php, en utilise les tableaux qui sont très intuitifs et très… puissants.  Pourtant pour des raisons d’occupation mémoire ou bien pour une utilisation très précise, eh bien ils sont gourmand. Petit tour d’horizon des tableaux et de leurs alternatives en php.

Les tableaux php : caisse omnipotents?

Conception

Soyons clairs : un tableau PHP, ce n’est pas un tableau C ou Java. Ce n’est pas une liste python, c’est… un tableau PHP. A la source, c’est une “ordered map”. Cela permet d’utiliser ces tableaux comme tableau, dictionnaire, liste, file, pile… Mais surtout, de manière sous-jacente cela signifie qu’en PHP tout ce qui sera rangé dans un conteneur de donnée (que ça soit un array ou autre chose), il y aura une association clé=>valeur.

Cela est extrêmement important car en PHP, cela signifie qu’avec un peu d’effort de conception, vous pouvez organiser vos tableaux pour qu’à l’usage tout soit en O(1). Vous sacrifiez un peu (beaucoup) de mémoire, mais ça va vite.
SI je prend le temps de dire cela, c’est qu’il arrive souvent qu’un développeur, habitué à des langages comme Java ou C construise son tableau comme un tableau indicé. Puis, comme il veut que ses données n’aient pas de duplicata, il fait une fonction du type :

[cc lang=”php”]
function insert($value,$collection){
if(array_search($value)!==false){
$array[] = $value;
}
}

[/cc]

Et ça c’est du O(n), donc le temps pour insérer un élément, au lieu d’être constant comme il l’est habituellement avec les tableaux php, sera croissant avec le nombre de données. Puisque nous sommes en php, rien ne nous interdisait pourtant de faire

[cc lang=”php”]
$array[$value]=isset($array[$value])?:true;
[/cc]

API

L’autre avantage des arrays PHP est l’API qui les accompagne. C’est cette API qui vous permettra d’utiliser les tableaux comme des piles/files (pop,push,shift), qui vous permettra aussi de voir les tableaux comme des ensembles (diff, merge, surcharge de l’opérateur + et -). Ces fonctions sont très nombreuses, et vous permettent d’économiser du temps de développement sur tout ce qui concerne les algorithmes de tri, de filtrage…

Les fonctions sur les arrays sont nommées de cette manière : array_nom_de_la_fonction. Et si la méthode a une variante qui accepte une callback, il suffira d’ajouter un “u” pour faire array_unom_de_la_fonction.

Les alternatives

Les alternatives que je présentes sont celles proposées par la SPL (Standard PHP Library). Je n’en présente volontairement que deux que j’ai utilisés récemment, mais un grand nombres de structures de données vous sont proposées. Vous aurez ainsi la possibilité d’utiliser une liste chaînée, une implémentation objet des tableaux, une pile et une file déjà codées. Mais place à deux structures que j’apprécie beaucoup.

Pour faire comme Java

Il faut faire plaisir aux fan de Java, il faut leur donner un tableau indicé à taille fixe qui ne se soucie pas des clés string des arrays.
C’est ainsi que fut créé SPLFixedArray. Son utilisation? comme un tableau java :
[cc lang=”php”]$array = new SPLFixedArray($size);[/cc] Contrairement à un tableau php habituel, il y aura d’emblée 5 cases de créées, et la taille sera de $size et non de 0. Un json_encode vous en assurera en imprimant :

{“0″:null,”1″:null,”2″:null,”3″:null,”4”:null}

Si, théoriquement un FixedArray est plus rapide (pas de hashmap) (5% sur la version 5.4, je ne sais pas pour la 5.5), son implémentation dans la 5.3 est légèrement plus lente qu’un array normal. Néanmoins, des progrès sont sans cesse faits et la conception en soit de la SPL évolue donc il faudra être patient. En fait la principale optimisation de la SPLFixedArray c’est l’utilisation mémoire. Ces derniers temps, j’ai migré un code qui se servait de matrice 10×10 de array vers SPLFixedArray. Auparavant, pour m’assurer du gain réel, j’avais été vérifier avec quelques benchmark le gain que je faisais et pour la mémoire, voici la différence :

  • Array : 225952 octets pour une matrice d’entiers 5×5
  • SPLFixedArray : 225632 octets pour une matrice d’entiers 5×5

gain : 320 octets pour 25 entiers stockés, ces entiers étant sur 64bits : nous faisons une économie de 320 octets pour 200 octets de données pures.

Cette tendance est réelle et confirmée par un gain de 1024 octets sur une matrice d’entiers 10×10.

SPLHeap

Se déclinant en MinHeap, MaxHeap et PriorityQueue, le tas est une structure de données que j’ai pu utiliser dans deux cas très précis, à savoir l’algorithme de Dijkstra et une insertion de données dans une collection de manière à ce que les nouvelles données ne cassent pas l’ordre désiré.

Ici il s’agit surtout d’éviter absolument des opérations de tri en O(nlog(n)) à chaque fois qu’on doit insérer une donnée. En effet même si les processeurs actuels sont rapides, c’est quand même assez long comme complexité. Consommer un “log(n)” à l’insertion permet d’éviter un tri complet à chaque fois. En plus cela permet de contrôler l’endroit où l’objet est inséré grâce à plusieurs paramètres pondérés.

Conclusion

Même si elle a certaines failles de conception la SPL vous offre des alternatives intéressantes pour ranger vos données de manière optimisée. Néanmoins les tableaux php restent sa plus grande force et permettent une optimisation temporelle des algorithmes qui est immense ! N’hésitez pas à réfléchir à la manière dont vous utilisez vos tableaux !

PHP 5.5 déprécie Mysql

Ca y est ! la version 5.5 de PHP qui est actuellement en version alpha jusque jeudi a marqué l’API Mysql qui commençait à dater comme dépréciée.

Cela signifie que désormais, à chaque appel de mysql_connect (ou de son équivalent pour les connexions persistantes) un WARNING vous sera envoyé vous conseillant de passer à Mysqli ou PDO. Si vous ne l’avez pas déjà fait, il n’est pas trop tard, et je vais vous rappeler (ou du moins vous présenter) quelques bonnes raisons de ce passage :

La sécurité

On ne vous le dira jamais assez, mysqli et PDO sont plus sécurisés. Pas simplement parce qu’ils proposent les requêtes préparées, qui sont naturellement “sécurisées” (à condition qu’on sache s’en servir) mais aussi parce que l’un comme l’autre corrigent les failles de mysql_ en ce qui concernent l’encodage, les connexions persistantes etc. Cela impliques quelques règles à respecter :

  • Il est obligatoire de donner la ressource de connexion à chaque fonction qu’on appelle. La POO simplifie cela puisque la méthode est liée au $this. Par contre le style procédural permis par mysqli_ vous oblige à écrire par exemple :[cc lang=”php”]$query = mysqli_query($connexion,’SELECT * FROM yourtable’);
    $result = mysqli_fetch_all($query);[/cc]
  • Sauf pour les requêtes dont vous savez qu’elles n’utilisent pas de paramètres, utilisez la fonction prepare. Attention néanmoins mysqli_ et PDO n’utilisent pas cette fonction de la même manière. PDO a deux grands avantages sur MySQLi en ce qui concerne les requêtes préparées : il permet des paramètres nommés et il permet de lier une valeur plutôt qu’une variable. Enfin pour PDO aller chercher le résultat d’une requête “normale” ou d’une requête préparée c’est la même chose donc les méthodes fetchAll et fetch existeront. Pour mysqli seul fetch existera et encore, il fonctionnera d’une autre manière que le fetch d’une requête normale.
    • Exemple de requête préparée avec PDO : [cc lang=”php”]$pdo = new PDO(‘yourDSN’,’user’,’pw’);
      $prep = $pdo->prepare(‘SELECT * FROM yourtable WHERE yourcol=:yourcol’);
      $prep->bindValue(‘yourcol’,"une chaîne avec des c’haractères embêt@nts’");
      $prep->execute();
      $result= $prep->fetchAll(PDO::FETCH_ASSOC);[/cc]
    • Exemple de requête préparée avec MySQLi :[cc lang=”php”]$mysqli = new mysqli(‘yourhost’,’user’,’pw’,’db’);
      $prep = $mysqli->prepare(‘SELECT * FROM yourtable WHERE yourcol=?’);
      $var = "une chaîne avec des c’haractères embêt@nts’",
      $prep->bindParam(‘s’,$var);
      $prep->bindResult($col1,$col2,$col3);//les résultats de chaque colonnes seront mis dans les variables associés
      $prep->execute();
      while($prep->fetch()){
      $result[] = array($col1,$col2,$col3);
      }[/cc]

     

Les fonctionnalités

L’ancienne API est ancienne et n’a pas été mise à jour avec Mysql 5 donc contrairement à PDO et mysqli elle ne pourra pas tout faire.
Au programme : requêtes multiples, support amélioré des transaction, support amélioré des conexions persistantes…

Migrer? mais comment?

En utilisant l’outil développé par Oracle.
En allant chercher quelques infos sur stackoverflow.

Comment un langage lambda peut-il devenir cool?

Dans ce titre un peu étrange se cache un certain enthousiasme : le Java qui m’énerve, me fait râler, me fait faire des choses répétitives, crades (classes anonymes) mais pourtant si stricte qu’on dirait un grand père réac est en train, enfin, de disparaître. Une nouvelle fonctionnalité, les lambda functions arrivera avec Java 1.8 et j’avoue qu’à mon sens ces expressions sont crées en Java de la plus belle manière qui soit, petit aperçu.

Ce qui importe : les parties codantes

J’ai assisté au Ch’ti JUG mardi dernier, la conférence était animé par Rémi FORAX qui a d’emblée mis le doigt sur un problème important en JAVA : la part très importante de cérémonie et de code superflu face aux parties codantes. Eh oui, plus que la déclaration des classes et des fonctions, en JAVA vous pouvez surcharger votre ligne de code avec des “cérémonies” très -trop- nombreuses.

L’idée est donc d’incorporer des fonctionnalités qui feront que les parties codantes seront vraiment plus importantes. Premièrement, on va essayer d’arrêter de créer des classes anonymes quand on veut juste une expression. En plus d’être très inefficace pour différentes raisons (accès disque multipliés…) cela prend pas mal de temps à coder, et en plus c’est difficilement parallélisable. Alors on va créer les fonctions lambda et les expressions statiques.

Par exemple, pour reprendre ce que nous a montré R.Forax, pour lister tous les dossiers contenus dans le dossier courant, la “vieille version” consistait en cela :
[cc lang=”java”]
public class DirectoryLister{
public static File[] listDirectory(File rootDir){
File[] files = rootDir.listFiles(new FileFilter(){
@Override
public boolean accept(File path){
return path.isDirectory();
}
});
return files;
}
public static void main(String[] args){
File root = new File(".");
for(File f: listDirectory(rootDir)){
System.out.println(f);
}
}
}[/cc]
Avec les lambda on peut faire, a première vue :
[cc lang=”java”]
public static File[] listDirectory(File rootDir){
File[] files = rootDir.listFiles((File file)->file.isDirectory());
return files;
}
[/cc]
La syntaxe pour une lambda est [cci lang=”java”](Type1 var1,Type2 var2)->expression[/cci] et si vous avez besoin de plus de lignes :
[cc lang=”java”](Type1 var1,Type2 var2)->{
var1.fonction();
var2.fonction();
return /* ce qu’il y a a retourner*/;
}[/cc]
Mieux encore, comme dans notre exemple il s’agit simplement d’appeler une fonction de l’objet de type File, on peut réduire [cci lang=”java”](File file)->file.isDirectory()[/cci] à
[cci lang=”java”]File::isDirectory[/cci].

Là où Java devient cool : les Stream

Presque tous les langages dynamiques possèdent les fonctions lambda, peu importe leur nom. Mais en Java, quand on réforme le langage (car derrière les lambda, il y a un vrai gros changement de Java quand même), on ne le fait pas pour si peu…
Alors on va créer l’idée des “Streams” et là c’est vraiment immense.
Pour expliquer ce qu’est un stream, rien de mieux qu’un schéma (merci V.Plantevin). Partons d’une collection, un tableau par exemple. Nous voulons le filtrer puis faire une opération sur chaque élément restant.
Les filtres sont dit “méthodes intermédiaires”, alors que le “foreach” est dit “méthode finale”.flux7L’idée c’est que les méthodes intermédiaires vont créer un pipeline extrêmement optimisé et qui peut utiliser toutes les ressources processeur moderne. Ce pipeline n’est construit, à la compilation, que s’il y a une méthode finale : on ne peut pas filtrer un flux sans lui appliquer quelque chose à la fin, sinon le compilateur ne sait pas créer le pipeline.

Alea jacta est

Pour télécharger la dernière version de la JDK 8 :
JDK 8 with lambda
N’hésitez pas à remonter les bugs :
lambda-dev@openjdk.java.net