Manuel d'apprentissage
⁂
À la découverte de Hoa

• ↩ Introduction
• Installation ↪

Cette section dévoile quelques atouts de Hoa.

Table des matières

1. Trois principes fondamentaux
2. Les points forts de Hoa
   1. Le noyau
   2. Les flux
   3. La sécurité et la sûreté
   4. La modularité
   5. L'interface graphique
   6. Le respect des standards
3. Ensemble de bibliothèques ou framework ?

Trois principes fondamentaux

En tout premier lieu, Hoa se définit comme un ensemble de bibliothèques. Une bibliothèque est un ensemble de fonctionnalités autour d'un sujet ou d'un domaine précis. La philosophie des bibliothèques est de proposer un environnement propre, logique et intuitif, dans lequel l'utilisatrice ou l'utilisateur peut développer efficacement, sereinement et rapidement. En effet, si elles sont bien conçues, les bibliothèques apportent un ensemble de solutions pour résoudre des problèmes de manières efficaces. Si les solutions sont pertinentes, alors le développement sera efficace. Ensuite, si les bibliothèques sont en harmonies entre elles, i.e. si elles sont génériques, alors on peut travailler sereinement : on sait que modifier un flux par un autre flux ne créera pas de régression dans notre programme car les interfaces sont scrupuleusement les mêmes. Enfin, comme les bibliothèques sont pensées de la même manière, on acquierera des automatismes à l'utilisation et on se surprendra à utiliser des bibliothèques sans presque en avoir lu la documentation.

En deuxième lieu, Hoa se veut être un pont entre le monde de la recherche et le monde de l'entreprise. En effet, la recherche est à la pointe de la découverte, des solutions, des avancées etc., mais elle manque de retour sur ses travaux. A contrario, l'entreprise est en contact avec une multitude d'utilisateurs et a besoin d'innover. Alors, Hoa essaye d'apporter des solutions venant du milieu de la recherche aux entreprises, ce afin de proposer des retours à la recherche et de l'innovation aux entreprises. Ces retours s'expriment sous la forme de commentaires, de contraintes ou de besoins. Et les innovations s'expriment sous la forme de solutions efficaces, performantes, une autre façon d'aborder un problème d'une manière plus générique ou plus optimale. Néanmoins, tout cela reste invisible aux deux milieux. Les utilisateurs, d'où qu'ils proviennent, utiliseront Hoa et pourront profiter de tous ces échanges enrichissants. On souligne que les contributions viennent autant du monde de la recherche que du monde de l'entreprise. C'est ce qui fait la richesse de Hoa. Notons que Hoa est utilisé entre autre par la fondation Mozilla, par le Laboratoire Informatique de Franche-Comté, ainsi que par l'Institut National de Recherche en Informatique et en Automatique.

Enfin, en dernier lieu, Hoa est développé en PHP. Ce langage est très intéressant. Il apporte une dynamique rarement rencontrée dans d'autres langages. Toutefois, en raison de son histoire, il est possible qu'on lui reconnaisse certaines faiblesses et certains manques. Notamment le fait qu'il n'offre pas de réelle bibliothèque standard comme le feraient d'autres langages. Hoa pallie à ce problème en proposant ses bibliothèques. L'objectif étant de redécouvrir PHP et de profiter de toute sa puissance. Cette redécouverte de PHP sera d'autant plus forte que les solutions apportées par Hoa sont les plus innovantes possibles. Mais n'oublions pas que Hoa propose un cadre de développement ; ainsi vous pourrez développer vos propres bibliothèques et vous assurer d'une certaine pérennité et d'une forte intégration dans tous les projets utilisant Hoa.

Les points forts de Hoa

Cette section décrit ce que l'on estime être les points forts de Hoa.

Le noyau

Le noyau de Hoa est au centre de toutes les bibliothèques, i.e. chaque bibliothèque requiert le noyau pour fonctionner. Ce dernier propose des fonctionnalités vitales pour le bon fonctionnement des bibliothèques et pour assurer une bonne cohésion de leurs fonctionnements.

Tout d'abord, le noyau est responsable du pré-chargement et chargement des bibliothèques, selon une taxonomie en famille, i.e. chaque bibliothèque définit un paquetage qui appartient à une famille. Par exemple, toutes les bibliothèques que Hoa propose appartiennent à la famille Hoa. Ainsi, l'exemple suivant permet d'utiliser un routeur et un dispatcheur :

from('Hoa')
-> import('Router.Http')
-> import('Dispatcher.Basic');

Notons que les fichiers sont pré-chargés, c'est à dire qu'ils sont en attente d'utilisation. Ainsi, tant que la classe Hoa\Router\Http n'est pas utilisée, le fichier ne sera pas chargé. En revanche, si le pré-chargement n'est pas effectué, une erreur sera naturellement levée.

Ensuite, le noyau permet le paramétrage des bibliothèques et des classes. Les paramètres peuvent influer sur le comportement qu'aura une bibliothèque. Ils s'expriment sous la forme de tableaux et se définissent avec des mots-clés et des paramètres. Le langage zFormat permet d'exprimer des manipulations sur les paramètres.

Le noyau abstrait également tous les chemins de votre programme, grâce au protocole hoa://. Ce protocole porte plusieurs types de données, mais il faut le voir dans la plupart des cas comme une suite de liens symboliques. Par exemple, hoa://Application/Public/ sera toujours l'accès au dossier qui contient les données publiques de votre programme. Ce dossier n'est pas forcément dans un dossier Application et ne s'appelle pas forcément Public, mais dans votre programme, vous direz simplement que ce chemin pointe vers tel dossier. Si jamais l'architecture de votre application se voit modifiée, alors vous n'aurez qu'à changer la cible du protocole, mais en aucun cas vous n'aurez à reprendre votre programme et modifier tous les liens. Par défaut, le protocole définit trois racines :

• hoa://Application/ concerne votre programme ;
• hoa://Data/ concerne toutes les données de votre programme ;
• hoa://Library/ concerne les bibliothèques de Hoa.

Par exemple, hoa://Data/Etc/Configuration/ contient les configurations de votre programme, tout comme hoa://Data/Variable/Cache/ contient les caches, ou hoa://Data/Variable/Database/ contient les bases de données ou encore hoa://Data/Bin/ qui contient des binaires pour manipuler votre application. Tous ces chemins n'existent pas nécessairement, ce sont une suite de liens symboliques. Naturellement, cela fonctionne en bas-niveau dans l'application :

from('Hoa')
-> import('File.Read');

$file = new Hoa\File\Read('hoa://Data/Temporary/Foo.txt');
echo $file->readAll();

Ou encore plus bas-niveau :

require 'hoa://Data/Etc/Configuration/.Cache/HoaTest.php';

Il est bien évidemment possible, grâce au noyau, de créer vos propres liens sur le protocole.

Le noyau propose également un système d'événements natif à PHP. Il est parfois très pratique d'utiliser ce paradigme. Cela permet une grande souplesse dans la façon dont les composants de notre programme peuvent communiquer entre eux. Ainsi, l'exemple suivant permet d'afficher tous les événements provenant des tests lorsqu'ils sont exécutés :

event('hoa://Event/Log/Test/Praspel')
    ->attach(function ( Hoa\Core\Event\Bucket $event ) {

        print_r($event->getData());
    });

Nous venons de parcourir les fonctionnalités principales fournies par le noyau.

Les flux

La majorité des langages destinés aux entreprises manipulent des flux. PHP, de par sa position de langage glu, est au centre de plusieurs technologies et doit donc gérer au mieux les flux.

Dans Hoa, il existe un mécanisme de gestion de flux très poussé. Ainsi, les fichiers, les sockets, certaines chaînes de caractères, le terminal etc., sont des flux. Plusieurs catégories de flux existent : comme les flux primitifs, les flux composites, les flux structurels, les flux d'entrées, de sorties, tampons, verrouillables etc.

Prenons l'interface Hoa\Stream\IStream\In qui permet de manipuler des flux en entrée (soit en lecture), on trouvera alors des méthodes comme read, readInteger, readFloat, readCharacter, readString, readArray etc. On trouvera toutes les méthodes inverses sur l'interface Hoa\Stream\IStream\Out pour les flux de sorties (soit d'écriture), tel que : write, writeInteger etc. Mais on trouve également l'interface Hoa\Stream\IStream\Structural pour caractériser des flux dits structurels, comme des arbres, tels que XML, YAML, JSON etc. On y trouvera alors les méthodes selectElements, selectDescendantElements, selectChildElements, selectAdjacentSiblingElement, querySelector etc.

Les flux composites sont quant à eux des flux qui contiennent des flux. Il est naturel de comprendre qu'un flux XML ne travaille pas forcément sur un fichier mais peut travailler sur une socket. Ici, les flux primitifs sont les fichiers et les sockets, et le flux composite est le flux XML, qui permet d'interpréter le contenu des flux primitifs comme étant du XML. Cela implique que si on modifie le flux primitif, tout le traitement effectué sur notre fichier XML restera inchangé. Encore mieux : le flux JSON, à l'instar du flux XML, est composite mais également structurel (en effet, autant XML que JSON définissent des arbres). Si un traitement est fait sur un fichier qui n'est plus du XML mais du JSON, on modifie simplement la classe utilisée pour lire notre flux primitif, mais les opérations de traitement qui suivent ne seront pas modifiées. Tout cela grâce aux nombreuses interfaces que proposent les flux. Ainsi, l'exemple suivant va sélectionner des éléments et lire leur contenu :

from('Hoa') -> import('File.Read') ->
  import('Xml.Read');

$xml = new Hoa\Xml\Read(
    new Hoa\File\Read('hoa://Data/Temporary/Foo.xml')
);

foreach($xml->querySelectorAll('foo > bar[attr^="ibute"]') as $element)
    echo $element->readAll() . "\n";

La sécurité et la sûreté

La sécurité et la sûreté du logiciel est une discipline Informatique à part entière. Cela consiste à s'assurer que rien de malveillant n'arrivera et que ce qui doit arriver arrivera, ou plus trivialement : notre programme fera tout ce qu'on a prévu, ni plus, ni moins, et dans de bonnes conditions.

Pour cela, il existe plusieurs approches, non mutuellement exclusives. L'une d'entre elle est le test. Des travaux de recherche ont été menés au sein même de Hoa afin de créer un générateur automatique de tests unitaires. Cela a donné lieu à la création d'un langage d'annotation et de spécification : Praspel. Ce langage est conçu pour exprimer des contraintes sur un algorithme et y effectuer plusieurs tests, de différents types, de différentes natures, à travers différents procédés. Ce langage constitue la base de notre générateur automatique de tests unitaires. Un rapport de recherche ainsi que des articles ont été publiés autour de ce sujet. Des conférences ont également été données.

Enfin, la sécurité, dans son sens le plus répandu, existe bel et bien dans Hoa. Toutes les données utilisateurs sont protégées et vérifiées au maximum. Notons que Hoa, dans sa conception, est basé sur une forme de discrétion, ce qui est une forme de sécurité. En effet, de part son protocole hoa:// qui masque tous les chemins, si jamais des erreurs apparaissent à l'utilisatrice ou l'utilisateur, aucune information ne pourra en être extraite. C'est un exemple certes, mais un parmi beaucoup.

La modularité

Hoa est conçu pour proposer un environnement propre de développement. Cela implique que vous pouvez vous-même développer au sein de Hoa, à travers le mécanisme de modularité appelé Hoathis. Ce mécanisme permet d'étendre ou d'ajouter des fonctionnalités aux bibliothèques standards que propose Hoa. Vous pouvez ainsi les utiliser soit dans un programme (en les déclarant au même niveau que votre programme), soit dans tous vos programmes (en les déclarant au même niveau que les bibliothèques standards).

De par la conception de Hoa, l'utilisation de vos bibliothèques se fera de la même manière que pour les bibliothèques standards. Ainsi :

from('Hoathis')
-> import('Test.Report.Xformat');

event('hoa://Event/Log/Test/Praspel')->attach(
    new Hoathis\Test\Report\Xformat()
);

On comprend que si le flux de rapports de tests utilise les interfaces de flux, alors il s'intégrera sans problème au reste de Hoa.

L'interface graphique

Un des problèmes majeurs lors de la création d'un programme est l'interface graphique. Il existe une multitude de bibliothèques, principalement pour micro-templating, mais aucune ne répond vraiment aux besoins. Ces besoins sont : dynamicité, modularité et extensibilité. Hoa propose un langage d'interface graphique sous forme XML qui répond à de très nombreux besoins : XYL.

XYL est un langage d'interface graphique multi-plateforme et multi-sortie, i.e. vous écrivez votre interface graphique une seule fois et vous demandez une interprétation particulière : vers un navigateur Web de bureau ou de mobile, vers une application native bureau ou mobile, vers une tablette, vers un terminal, vers un fichier PDF, vers un fichier XML, JSON etc. Quand on parle de multi-plateforme, ça sous entend plusieurs systèmes, avec les particularités de chacun.

XYL propose un système de yielding qui permet de fixer des données dans l'interface graphique de manière dynamique et qui permet de créer des composants graphiques.

<?xml version="1.0" encoding="utf-8"?>
<?xyl-stylesheet href="hoa://Library/Xyl/Css/Core.css"?>
<?xyl-use href="Comments.xyl"?>

<document xmlns="http://hoa-project.net/xyl/xylophone">
  <title>Exemple</title>

  <h1>Commentaires</h1>

  <comments bind="?data/to/comments" />
</document>

et notre fichier Comments.xyl :

<?xml version="1.0" encoding="utf-8"?>

<definition xmlns="http://hoa-project.net/xyl/xylophone">
  <yield name="comments">
    <div bind="comment">
      <img src="?avatar" />
      <p><value bind="?pseudo" /> dit :</p>
      <blockquote bind="?message" />
    </div>
    <hr />
  </yield>
</definition>

Mais XYL propose également un système d'overlay, i.e. la capacité d'ajouter une partie d'une interface graphique dans une interface déjà existante. Ce qui est très pratique pour ajouter des modules sur un site de commerce par exemple.

XYL est un langage prometteur, assez différent de ce qui se fait actuellement, mais qui a un avenir certain.

Le respect des standards

Hoa insiste énormément sur le respect des standards. En effet, les standards assurent une homogénéité, une interopérabilité et une pérennité. Des standards écrits par le W3C ne peuvent par exemple pas être ignorés. De même pour les RFC écrites par l'IETF, les normes ISO ou encore les normes IEEE telle que la norme POSIX.

Les normes ne manquent pas mais sont vitales. Leur respect est parfois difficile et compliqué. C'est pourquoi Hoa propose des bibliothèques respectueuses de ces standards. Ainsi, vous n'aurez pas à vous soucier de la syntaxe ou de la sémantique des données manipulées ou produites, vous êtes assurés quelles seront compréhensibles et exploitables par d'autres programmes.

Ensemble de bibliothèques ou framework ?

Avoir un ensemble de bibliothèques est pratique et utile pour développer ses propres outils, voire ses propres bibliothèques. En revanche, certaines contraintes rencontrées au quotidien nous obligent à travailler vite, ce qui implique d'avoir des processus automatisés. C'est en cela que les frameworks sont un atout de poids : ils automatisent des tâches.

Hoa est avant tout un ensemble de bibliothèques. Néanmoins, il est également proposé un aspect framework, comme une preuve du concept de la modularité des bibliothèques. C'est pourquoi, en ajoutant quelques outils, vous pouvez ajouter à Hoa un aspect framework et donc automatisé.

La découverte de ses outils se fera au fur et à mesure de la documentation.

• ↩ Introduction
• Installation ↪