Avec Spoggy, prenez des notes et partagez-les

Dans le RDF jusqu'au cou depuis quelques années, il me manquait un outil de prise de notes collaboratives, c'est ainsi qu'est né "S P O G G Y".
Au départ "SPOG" pour "Sujet Predicat Objet Graph", c'est devenu SPOGGY, parce que ça fait plus friendly.

Quels fichiers utiliser avec SPOGGY ?

Si vous êtes sollicité par un ami ou une connaissance pour utiliser SPOGGY, il vous a certainement envoyé un fichier au format ".json" ou un lien vers ce fichier.
S'il vous l'a envoyé par mail, vous devrez le télécharger sur votre ordi/smartphone/tablette...

Par exemple, nous avons 3 fichiers de ce type ici à cette adresse :  https://github.com/scenaristeur/smag0-connaissance/tree/master/meet-up_conf
Attention, il faudra télécharger la version "raw" de ces fichiers (cliquer sur le lien "raw", puis clic-droit, et "Enregistrer sous":

- ma prise de notes de l'atelier RedisLabIot d'hier soir (raw)
- ma prise de notes de la conf "de OWL à Fameus" lors du hackathon "HackMyCity" de ce week-end (raw)
- ma prise de notes de la conf sur l'animation par "Les Nouvelles du Front(end)" (raw)

(En cours de dev, à tester.  Spoggy peut aussi lire les fichiers Turtle (.ttl), + rdf et owl)

Comment utiliser SPOGGY ?

Vous pouvez tester SPOGGY à l'adresse https://spoggy0.firebaseapp.com/

1. En ouvrant cette page, on vous demande un pseudo, saisissez celui qui vous plaira et validez par "Entrée"
2. Une fois votre pseudo validé, vous arriver sur la partie "chat" pour échanger avec les autres utilisateurs connectés, 
3.  C'est pourquoi je vous invite donc à cliquer directement sur l'icône "chat" en haut à droite, qui permet de basculer chat/pas chat, et vous arriver sur une interface très ressemblante, mais avec plus de boutons, trois icones roses en haut à droite, un bouton "Edit" en haut à gauche , des petits boutons verts en bas, à gauche et à droite, et encore plus bas, une barre blanche entourée d'un cadre noir où il est écrit "Tapez votre triplet..."
4. Cette barre blanche est un champ de saisie où vous pouvez envoyer des commandes à l'application SPOGGY, et les deux commandes qui nous intéressent dans un premier temps seront "/i" pour importer, et "/e" pour exporter 
5. Pour importer le fichier que votre ami vous a envoyé, ou l'un des exemples contenu dans https://github.com/scenaristeur/smag0-connaissance/tree/master/meet-up_conf, utiliser donc la commande "/i" sans les guillements, une fenêtre "Import JSON" devrait s'ouvrir avec un bouton "Parcourir" ou "Selectionner Fichiers", vous permettant d'aller chercher le fichier concerné.
6. En sélectionnant le fichier RedisLabIot, vous devriez voir quelque chose ressemblant à l'image présente en début d'article

Le Rôle des boutons

- boutons verts pour vous déplacer dans le graphe, vous pouvez aussi utiliser la souris, la molette ...

- bouton "Edit" pour ajouter des noeuds, des liens, 

- les boutons roses : régler la distance entre les noeuds...  + d'autres idées en cours de développement

- une fois que vous avez modifié un graphe, vous pouvez le pusher sur github, ou me l'envoyer par mail, pour que je le mette à jour. Vous trouverez mes coordonnées sur cette page : http://smag0.blogspot.fr/2017/08/smagyun-comment-acceder-aux.html

Sparql update un Polymer element pour mettre a jour un sparql endpoint

Objectif de cet article : Créer un element Polymer pour mettre à jour un sparql endpoint (fuseki)

inspiration : https://www.youtube.com/watch?v=k1eR_3KqJms

premier test : sparql-statements (recupérer les infos RDF sur un serveur sparl / fuseki en utilisant iron-ajax)

serveur fuseki  : http://rdf-smag0.rhcloud.com/

prérequis :
installation de nodejs, yeoman

Polymer propose polymer:seed, un element modèle servant d'exemple pour la création d'elements Polymer.

Au boulot on va créer un element "sparql-update"
sous l'invite de commande dos tapez :

yo polymer:seed sparql-update

complétez avec vos infos -6> un module modèle est créé dans votre repertoire.
Pour le lancer utilisez la commande :  polyserve

Le nouvel element généré est accessible à l'adresse :
http://localhost:8080/components/sparql-update

quelques soucis parfois d'affichage, (un certain temps pour mettre à jour ? allez voir dans le fichier README.RD généré pour avoir différents liens et testez notamment celui-ci : http://localhost:8080/components/sparql-update/test/ ) , une page de tests devrait finir par s'afficher.

Ce qui nous intéresse, Thérèse , ensuite c'est le module lui-même, on utilisera deux pages :

• la page du module :  http://localhost:8080/components/sparql-update/
• la page de demo accessible par le bouton "DEMO" en haut à droite

Laisser le terminal ou vous avez lancez polyserve ouvert et ouvrez un autre terminal pour installer l'element "iron-ajax" avec la commande  : 

bower install --save PolymerElements/iron-ajax

et incorperez cet element dans sparql-update.html avec : <link rel="import" href="../iron-ajax/iron-ajax.html"> juste après <link rel="import" href="../polymer/polymer.html">

supprimer les elements inutiles dans le modeles : 

• dans le fichier  sparql-update.html 

.author dans template/style

et ne garder que "properties" dans la definition js de l'element : 

il ne devrait vous rester plus que ceci : 

<link rel="import" href="../polymer/polymer.html">

<link rel="import" href="../iron-ajax/iron-ajax.html">

<!--
An element providing a solution to update sparql endpoint like Fuseki.
(https://github.com/scenaristeur/sparql-update)

Example:

    <sparql-update></sparql-update>

Example:

    <sparql-update>
      <h2>Hello sparql-update</h2>
    </sparql-update>

@demo demo/index.html
@hero hero.svg
-->

<dom-module id="sparql-update">

  <template>

    <style>

      :host {

        display: block;

        box-sizing: border-box;

      }

    </style>

  </template>

  <script>

    Polymer({

      is: 'sparql-update',

      properties: {

       

      }

    });

  </script>

</dom-module>

Nous avons maintenant un élement propre et on va pouvoir y mettre notre propre (ou sale ?) code

On incorpore maintenant notre element "iron-ajax" qui va se charger d'effectuer la requete POST vers notre serveur Fuseki :

<iron-ajax/iron-ajaxauto
url=""
handle-as="json"
on-response="{{handleResponse}}"></iron-ajax>

le mieux c'est de jeter un oeil au code

Projet, idée, problème... partager sous forme de graphe, collaborer... et bien plus encore...

[ cet article fait partie de la série RDF FACILE - Mon petit BigData ]

Si mes explications ne sont pas claires, y'a toujours Wikipedia : https://fr.wikipedia.org/wiki/Resource_Description_Framework

Parti d'un projet un peu loufoque, il est vrai d'"un robot qui range ma chambre", il m'est très vite apparu que ce projet d'envergure n'était pas simple à partager avec mon entourage, et encore moins avec des inconnus.

Pour ce projet, j'avais imaginé non pas un robot qui rangerait, mais une multitude de robots, d'objets connectés, de modules qui s'entraideraient, collaboreraient.

Ils devaient pour ce faire s'échanger des informations dont la structure devaient être libre de toute modification au cours du temps, et chacun de ces robots aurait la possibilité de compléter, corriger les informations en fonction de ses capacités à capter l'environnement.

Au fil de mes recherches, le format qui me parut le plus adapté fut le RDF et je n'ai rien trouvé de mieux depuis, mais la discussion reste ouverte ;-)

RDF

Le rdf nous permet, en effet, à partir de notions toutes simples que tout le monde peut comprendre, de partager et d'échanger, de décrire tout et n'importe quoi... J'imaginais alors que pour que mes robots puissent comprendre leur environnement, il leur fallait déjà le connaître un petit peu... Mes quelques connaissances sur le Machine Learning en plein boom me laissant supposer que ces différents modules pourraient être dotés d'ici peu d'une quelconque intelligence artificielle répondant aux besoins qui leur seraient demandés : apprentissage, adaptation au contexte, à l'utilisateur...

La première notion essentielle, le triplet, est décrite un peu plus bas, mais avant ça, nous devons parler de l'information...

L'information

Si je vous dis "Voiture", tout le monde ou presque voit à peut près ce que cela représente. Méa Culpa à ceux qui pourraient penser que je les prends pour des ânes, mais les notions que l'ont va aborder ici, même si elles sont simples, imposent d'oublier tout ce que vous savez, ou plutôt de regarder le monde sous un autre angle, avec un peu plus de recul... Et de bien considérer que chacun peut posséder une vision différente de chaque concept, selon son origine, ses habitudes, sa culture...

Si cette fois, je vous dis "La Voiture de David", vous m'accorderez que l'information est plus précise... Dans "La Voiture de David est jaune et c'est une Opel Corsa", on aura encore plus d'informations...

Dans un premier temps, et pour se rapprocher de ce que tout le monde connait, ce que nous allons devoir faire (tant que le Natural Langage Processing n'est pas intégré au site), c'est de découper cette information... c'est un peu comme un tableau à deux lignes, avec dans la première ligne, les champs et dans la deuxième les valeurs.

	champ 1	champ 2	champ 3	champ 4	...	...
Ce que nous voulons décrire	valeur 1	valeur 2	valeur 3	valeur 4	...	...

Par exemple, pour décrire ma voiture, je pourrais utiliser le tableau suivant :

	marque	modèle	couleur	vitesse maxi	propriétaire	position actuelle
Voiture de David	Opel	Corsa	Jaune	128 000	David	Lyon

Comme vous avez pu le constater, les propriétés (champs dans le tableau) sont très libres et nous laissent le loisir de décrire tout et n'importe quoi... J'utilise ici le terme "propriété", et ceux qui sont allés voir la page Wikipédia sur le RDF aurons constaté qu'il est mentionné "prédicat"... Et bien les deux sont équivalents... et oui, faudra vous y faire...

Bon allez, je n'y tiens plus... passons au triplet...

Le Triplet

Repartons de l'exemple que nous avons pris précédemment : "La Voiture de David est jaune et c'est une Opel Corsa".

Nous avons découpé les informations de manière atomique dans le tableau à deux lignes... et bien ce tableau que n'importe qui est capable de reproduire, pour décrire n'importe quel concept, objet, procédure..., nous donne tout naturellement les triplets que nous attendions...

Le triplet se matérialise sous la forme de trois éléments :

• un sujet : c'est la chose que l'on va décrire,
• un objet : c'est une chose avec laquelle notre sujet est lié,
• une propriété (ou prédicat) : c'est la nature de la relation entre le sujet et l'objet.

Ainsi notre tableau précédent nous donne les triplets suivants :

(Voiture de David, marque, Opel)
(Voiture de David, modèle, Corsa)
(Voiture de David, couleur, Jaune)
(Voiture de David, vitesse maxi, 128 000) --> enfin seulement dans les bonnes descentes...
(Voiture de David, propriétaire, David)
(Voiture de David, position actuelle, Lyon)

A quoi ça sert ? me direz-vous ? Ouais super... j'ai perdu 10 minutes à lire un truc qui ne sert à rien...
Meuh non, va voir plus bas !

Le Graphe

Bien maintenant que nous avons nos triplets, envoyons-les dans un "graphMaker" tel que http://smag0.meteor.com,

•  http://smag-smag0.rhcloud.com/DreamCatcher/   ( en cas de message d'erreur à l'ouverture de la page, attendez 30 secondes et actualisez la page --> pour laisser au serveur le temps de redémarrer l'appli.)
• https://scenaristeur.github.io/dreamcatcherAutonome/

avec quelques exemples de fichiers rdf /ttl /owl (http://smag-smag0.rhcloud.com/dca/ontologies/)

On obtient alors le début d'un graphe : 

Mais les choses deviennent intéressantes lorsque l'on rajoute de nouveaux triplets :

(Voiture de David, type, Voiture)
(David, type, Personne)
(Lyon, type, Ville)
(Voiture, subclassOf, Vehicule)
(David, habite, Lyon)
(Paris, type, Ville)
(Madrid, type, Ville)
(Paris, capitale de, France)
(France, type, Pays)
(Soleil, couleur, Jaune)
(Lyon, sameAs, http://fr.dbpedia.org/page/Lyon)
...

Oulà ! STOP !, c'est quoi cette dernière ligne ??? !!! ce dernier "triplet", comme ils disent ???

Attention ! Là, on rentre dans le vif du sujet

Sur cette dernière ligne (Lyon, sameAs, http://fr.dbpedia.org/page/Lyon), qui et toujours un triplet, y'a un max de nouvelles notions, mais j'imagine que si vous avez tenu jusque là, vous êtes prêt à affronter la suite :

• sameAs : la propriété "sameAs", comme vous pourrez le constater, si le RDF continue de vous intéresser, nous permet de spécifier que le sujet (Lyon) et l'objet (http://fr.dbpedia.org/page/Lyon) du triplet représentent la même chose.
  Et c'est là, la plus grande qualité du RDF, "it's a kind of magic", c'est là que la magie "s'opère"... C'est là que s'ouvre une infinité de possibilité...
  Vous pouviez déjà grâce au RDF tout décrire, vous pouvez maintenant connecter votre graphe à d'autres graphes, d'autres bases de données RDF crées par d'autres... comme celle de DBPedia, qui reprend les informations contenues dans Wikipedia, et vous les propose au format RDF : allez jeter un œil sur la page en question : http://fr.dbpedia.org/page/Lyon et vous verrez d'autres propriétés apparaître, comme la population, la superficie, les monuments... ainsi que des liens vers d'autres bases de données ou des endpoint sparql
• http://fr.dbpedia.org/page/Lyon : à décrire...
• prefix
• sparql

La suite ?

Bandes d'impatients, commencez par jeter un oeil sur dreamcatcher -> http://dreamcatcher-smag1.rhcloud.com/#!/outils (patientez 30 secondes que le serveur redémarre l'appli)

 vous y trouverez l'aide pour vous balader dans les graphes..., sinon en attendant la suite, vous pouvez également interpeller le fautif, lui posez vos questions, ou faire part de vos attentes, vos idées sur Twitter : @DFaveris
d'autres infos techniques se trouvent sur http://smag0.blogspot.fr

Un bon tendeur...
ça tient bien, tiens, ça tombe bien !

Insert d'informations sur un serveur Fuseki, post

1. installer fuseki pour qu'il soit accessible sur http://127.0.0.1:3030

2. creer un fichier smag.html  dans le repertoire webapp du serveur fuseki, avec le contenu qui suit et y accéder via http://127.0.0.1:3030/smag.html


<!DOCTYPE html>
<!-- https://github.com/scenaristeur/coolitude4/blob/master/Coolitude4/src/org/favedave/smag0/coolitude4/projet/Projet.java -->

<html>
    <body>
  
  
    </body>
   <script>
var debutRequete = "INSERT DATA { GRAPH <http://example/bookStore> {";
var finRequete = "} }";
var data="test";

</script>


<script>
function post(path, params, method) {
    method = method || "post"; // Set method to post by default if not specified.

    // The rest of this code assumes you are not using a library.
    // It can be made less wordy if you use one.
    var form = document.createElement("form");
    form.setAttribute("method", method);
    form.setAttribute("action", path);
console.log(params);

    for(var key in params) {
        if(params.hasOwnProperty(key)) {
            var hiddenField = document.createElement("input");
            hiddenField.setAttribute("type", "hidden");
            hiddenField.setAttribute("name", key);
            hiddenField.setAttribute("value", params[key]);

            form.appendChild(hiddenField);
         }
    }


  
  
       document.body.appendChild(form);

    form.submit();
}



<!--post('/contact/', {name: 'Johnny Bravo'}); -->
//post('http://127.0.0.1:3030/test/update', {"update" : update});


function constructRequete(){

 var update  =  "PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#> ";
 update +=  "PREFIX rdfs:   <http://www.w3.org/2000/01/rdf-schema#>";
     update += "PREFIX smag:   <http://smag0.blogspot.fr/NS#>";
     update += "PREFIX zoo:   <http://example.org/zoo#>";
     update += "PREFIX owl: <http://www.w3.org/2002/07/owl#>";
     update += "PREFIX ex: <http://example.org#>";
update+= "INSERT DATA {";
 //update += "GRAPH <http://smag0.blogspot.fr/GraphTest>{";
  //update += "smag:RobokIze    rdf:type         smag:Site .";
  //update +="smag:RobokIze   smag:objectif         'un site de vente revente piece detachees , pour robots, et objets connectes' ." ;
//     update += "ex:cat     rdfs:subClassOf  ex:animal .";
//     update += "zoo:host   rdfs:range       ex:animal .";
//     update += "ex:zoo1    zoo:host         ex:cat2 .";
//     update += "ex:cat3    owl:sameAs       ex:cat2 .";
//    update += "ex:cat3    owl:sameAs       ex:cat2 .";
  
    var sujet=document.getElementById("sujet").value;
    var propriete=document.getElementById("propriete").value;
    var objet=document.getElementById("objet").value;
 update += "smag:"+sujet+"    smag:"+propriete+"         smag:"+objet+" .";

 // fin requete avec graphe var finRequete = "} }";
 var finRequete = "}"; // fin requete sans graphe

update+=finRequete;
console.log(update);


post('http://127.0.0.1:3030/test/update', {"update" : update});
    //console.log(update);
  
    //console.log(document.getElementById("sujet").value);
    //window.location.assign('http://127.0.0.1:3030/smag.html');
//modifier la pause créée par l'alerte --> ceci permet la mise à jour par la fonction post
    alert(update);
    maj();
}

function httpGetAsync(theUrl, callback)
{
    var xmlHttp = new XMLHttpRequest();
    xmlHttp.onreadystatechange = function() {
        if (xmlHttp.readyState == 4 && xmlHttp.status == 200)
           callback(xmlHttp.responseText);
            //console.log(xmlHttp.responseText);
             //document.getElementById("result").innerHTML = xhttp.responseText;
    }
    xmlHttp.open("GET", theUrl, true); // true for asynchronous
    xmlHttp.send(null);
}

function updateDiv(data){
var myJSONOBJECT= eval('(' + data+ ')');
// ou var myJSONOBJECT= JSON.parse(data, reviver);
var bindings = myJSONOBJECT.results.bindings;
//console.log("update");
//var resultat="";
var list = document.getElementById('resultats');
while (list.firstChild) {
    list.removeChild(list.firstChild);
}
for(i in bindings) {
  var binding = bindings[i];
  //alert(binding); // a for-loop to print all the bindings
  sujet=binding.s.value.split("#")[1];
  propriete=binding.p.value.split("#")[1];
  objet=binding.o.value.split("#")[1];
//  resultat=sujet +" "+propriete+" "+objet;
 // console.log("resultat :"+resultat);
var entry = document.createElement('li');
entry.appendChild(document.createTextNode(sujet));
entry.appendChild(document.createTextNode("  -> "));
entry.appendChild(document.createTextNode(propriete));
entry.appendChild(document.createTextNode("  -> "));
entry.appendChild(document.createTextNode(objet));
list.appendChild(entry);
}
//document.getElementById("result").innerHTML = resultat;

//var bindings = sr.results.bindings;

// JavaScript  for...in loop iterates
// through the properties of bindings array
// which are [0,1,length-1] as opposed to the
// array item.

//for(i in bindings) {
 // var binding = bindings[i];
 // alert(binding); // a for-loop to print all the bindings
//}

// The only difference here (a subtle one) is
// that the iterator variable is n as opposed to r
// n=name, r=row index
//for(i in bindings) {
  //var binding = bindings[i];
  //for(n in binding) {
  //  alert(binding[n].value); // a nested for-loop to print binding values
 // }
//}



}


function maj(){
//console.log('maj');
httpGetAsync('http://127.0.0.1:3030/test/query?query=select+*+where{%0D%0A%0D%0A%3Fs+%3Fp+%3Fo}%0D%0A&output=json',updateDiv);

}

</script>



<form name="form1" onsubmit="constructRequete()">
<input type="texte" name="q" value="a">

 <input type="submit">
</form>

<ul id="resultats"></ul>

<div id="result">

</div>

<script>

setInterval(function(){ maj(); }, 3000);
//maj();

            var inputSujet = document.createElement("input");
            inputSujet.setAttribute("type", "text");
            inputSujet.setAttribute("name", "sujet");
            inputSujet.setAttribute("id", "sujet");
            inputSujet.setAttribute("placeholder", "Sujet");
          
            form1.appendChild(inputSujet);
          
            var inputPropriete = document.createElement("input");
            inputPropriete.setAttribute("type", "text");
            inputPropriete.setAttribute("name", "propriete");
            inputPropriete.setAttribute("id", "propriete");
            inputPropriete.setAttribute("placeholder", "propriete");

            form1.appendChild(inputPropriete);
          
            var inputObjet = document.createElement("input");
            inputObjet.setAttribute("type", "text");
            inputObjet.setAttribute("name", "objet");
            inputObjet.setAttribute("id", "objet");
            inputObjet.setAttribute("placeholder", "Objet");

            form1.appendChild(inputObjet);
  
    // console.log(document.getElementById("sujet").value);
</script>


</html>

Visualiser le graphe d'une ontologie online (Processing, Javascript, XML)

Vous avez un fichier (ontologie ou base de connaissance) au format owl ou rdf, vous pouvez visualiser les classes le graphe (enfin pour l'instant, il n'y a que les classes : http://smag-smag0.rhcloud.com/saisie_projet (update : une version plus récente : http://smag0.blogspot.fr/2015/08/dreamcatcher-lattrape-reves.html )

Si vous n'en avez pas, vous pouvez tester avec la méthode Diamond, http://smag-smag0.rhcloud.com/ontologies/diamondMethode.owl que l'on a créé précedemment (http://smag0.blogspot.fr/2015/06/comment-creer-une-methode-pour-smag0-la.html)

Ou mieux, encore avec la pizza.owl ( http://protege.stanford.edu/ontologies/pizza/pizza.owl ), bien connue de tous ceux qui se sont intéressés un jour aux ontologies ;-).

--> possibilité de charger un fichier depuis votre disque dur
--> possibilité de glisser de nouveaux éléments pour créer un nouveau Projet (projet, acteur, environnement...)
--> possibilité de déplacer les noeuds,
--> possibilité de selectionner les noeuds (se positionner sur un noeud + touche CTRL)
--> possibilité de sauvegarde/chargement  des graphes ( les données sont stockées sur votre ordinateur, dans le localstore (en test) :

• documentation localstore FR : http://www.alsacreations.com/article/lire/1402-web-storage-localstorage-sessionstorage.html 
• documentation localstore EN : http://www.w3schools.com/html/html5_webstorage.asp

Tout ça avec P5Js, version web de Processing, en mode Javascript... 

Ajouter une méthode simple à un projet Smag0

Nous avons tenté d'expliquer dans l'article http://smag0.blogspot.fr/2015/06/comment-creer-une-methode-pour-smag0-la.html comment créer une méthode, en nous attaquant à la méthode Diamond. Mais cette méthode est complexe, et longue à mettre en place, on verra ça plus tard.

N'allons pas trop vite en besogne, procédons par ordre. Pour l'instant nous avons la possibilité d'enregistrer les projets ou les instructions que l'on veut envoyer à notre maison, via l'appli Coolitude4, ou via la page des projets, nous avons la possibilité d'ajouter des commentaires sur les projets proposés, et d'extraire de ces projets les termes importants, de les enregistrer au format RDF. Si RDF ne vous dit rien, jetez un petit coup d'oeil sur https://fr.wikipedia.org/wiki/Resource_Description_Framework pour que ce soit plus clair.
(NB : les liens mentionnés sont susceptibles de changer, merci de me le signaler, si vous n'y trouvez plus rien).

Une fois que l'on a notre projet, ou notre requête envers notre maison (voir ASACURQRSC ), 
le système doit posséder des méthodes pour analyser, interpréter, exécuter les instructions.
Partons donc d'un truc tout simple, par exemple... il est 20h36, c'est l'heure de manger, je voudrais manger des pâtes, c'est mon projet, ça devient une requête envers le système qui serait peut-être un jour capable de me faire cuire des pâtes sans me répondre " va te faire cuire un œuf".
Pour que le système puisse y parvenir, il va avoir besoin d'une méthode, comme nous quand on va sur http://www.marmiton.org ... mais en attendant qu'il aille y chercher des recettes complexes, tentons d'établir une méthode simple pour transmettre au système la méthode pour cuire des pâtes.

Primo : c'est quoi la méthode pour faire cuire des pâtes ??
source  : Farfalle - Barilla
 (je dois être le seul mec de tout l'internet à prendre mon code source sur les paquets de pâtes Barilla ;-%)

Modalité de cuisson pour 100g de pâtes :
1 litre d'eau
7g de sel

Faire bouillir l'eau et ajouter le sel.
Verser les pâtes et remuer de temps en temps.
Temps de cuisson 10 min.
Egoutter les pâtes.

En décomposant par étape, en gros, ça ferait :
1. Faire bouillir l'eau
2. Ajouter le sel
3. Verser les pâtes
4. Remuer de temps en temps (pendant 10 minutes )
5 Egoutter les pâtes

Le but étant de créer une méthode exploitable, enregistrable, partageable, modifiable, n'ayant pas trouvé mieux que RDF pour décrire, on va tenter de se le faire avec des triplets, comme ça  :
(voir aussi http://www.w3.org/2001/sw/BestPractices/OEP/SimplePartWhole/)

ici, on va utiliser la propriété rdf:type pour dire que CuireDesPâtes est_une Methode, ou que FairteBouillirEau est_une Etape...

{CuireDesPâtes  rdf:type  Methode}
{FaireBouillirEau rdf:type Etape}
{AjouterSel rdf:type Etape}
{VerserPâtes rdf:type Etape}
{Remuer rdf:type Etape}
/* avoir comment faire le de temps en temps, et le attendre 10 mins... faire les deux actions en parrallèle ??? temporiser ??*/
{EgoutterPâtes rdf:type Etape }

Voilà nos 5 étapes.

Ensuite, pour dire que la méthode CuireDesPâtes est composée de plusieurs étapes nommées FaireBouillirEau, AjouterSel..., on utilisera dc:hasPart, ce qui donnera

{CuireDesPâtes dc:hasPart FaireBouillirEau }
{CuireDesPâtes dc:hasPart AjouterSel
{CuireDesPâtes dc:hasPart VerserPâtes
{CuireDesPâtes dc:hasPart Remuer
{CuireDesPâtes dc:hasPart Attendre10Min } //encore à définir
{CuireDesPâtes dc:hasPart EgoutterPâtes }


on pourra compléter de la manière suivante en utilisant rdf:first pour dire que FaireBouillirEau est la première étape de la méthode CuireDesPâtes.

{CuireDesPâtes rdf:first FaireBouillirEau }

A ce stade, on serait tenter d'utiliser les Collections RDF : https://code.google.com/p/collections-ontology/wiki/RDFContainersAndCollections
mais ceci ne conviendrait pas, on créerait une Sequence avec rdf:Seq, mais on serait obligé de numéroter les étapes, alors que nous voulons quelque chose de souple. Ainsi, si j'ai envie de me créer ma propre méthode CuireDesPâtes2, et que moi, quand je fais des pâtes, j'ai l'habitude de mettre un couvercle, pour que la température de l'eau augmente plus vite ( ce qui n'est pas recommandé par Barilla, cela dit en passant... que ce soit clair entre vous et moi !). Bon admettons que l'on veuille rajouter une étape comme MettreCouvercle... Si on numérote les étapes avec les  propriétés préconisées rdf:_1, rdf:_2..., on sera embêté lors de l'insertion, il faudra renommer toute la suite, de même si on veut supprimer une étape. On va plutôt utiliser une propriété qui nous dira le "suivant" de FaireBouillirEau est AjouterSel.  Cette propriété "suivant" ou "next" (en anglais) ne semble pas avoir été prévu dans les vocabulaires rdf ou rdfs... Comment faire ...??? là se pose la question de tout développeur normalement constitué, qui s'est un peu penché sur RDF, et la notion de réutilisation des vocabulaires. Dois-je créer ma propre propriété avec mon propre prefix, un truc du style "smag:next"???

Que nenni, car c'est là qu'intervient notre ami Lovokfnorg ou plutôt http://lov.okfn.org/... Qui c'est celui-là ? un moteur de recherche de vocabulaires RDF... et en lui demandant s'il connait quelque chose qui correspondrait à notre "next" tant désiré, il nous répond :

• xhv:next(xhv)0.780
  

  7 occurrences in 5 LOD datasets

  http://www.w3.org/1999/xhtml/vocab#next

  http://www.w3.org/ns/rdfa#term next

  rdfs:comment next refers to the next resource (after the

  localName next

  http://www.w3.org/ns/rdfa#uri http://www.w3.org/1999/xhtml/vocab#next
• dqm:next(dqm)0.532
  

  n/a (use in LOD)

  http://purl.org/dqm-vocabulary/v1/dqm#next

  rdfs:comment Links an instances to the next instance in an ordinal scale. @en

  localName next
• olo:next(olo)0.532
  

  n/a (use in LOD)

  http://purl.org/ontology/olo/core#next

  rdfs:label has next @en

  rdfs:comment Associates the next slot in an ordered list. @en

  localName next

on a 71 réponses (peut-être plus quand vous lirez cet article), et déjà, les trois premières nous conviennent... Quelle utilité d'en créer une 72ème qui ne sera utilisée par personne d'autre que par moi. Prenons la plus populaire : xhv:next

On peut donc écrire (non, je ne met pas le couvercle, vous le mettrez si vous voulez... en plus , y'a des risques de débordement...) les triplets suivants :

{ FaireBouillirEau xhv:next AjouterSel }
{AjouterSel xhv:next VerserPâtes }
{VerserPâtes xhv:next RemuerDeTempsEnTemps }
{VerserPâtes xhv:next Attendre10Min }
{Attendre10Min xhv:next EgoutterPâtes }



On a maintenant une structure cohérente sans trop mettre les pieds dans le plat... de pâtes. Bon ok, c'est nul... Avec VerserPâtes qui possède deux xhv:next : RemuerDetempsEnTemps et Attendre10Min.

On a maintenant tout ce qu'il faut pour compléter notre méthode CuireDesPâtes. on peut par exemple décomposer les étapes... avec les propriétés dc:hasPart, rdf:first et xhv:next
L'étape FaireBouillirEau pourrait être composée d'autres étapes, comme SortirCasserole, RemplirEau, PoserSurGaziniere, AllumerLeFeu... et oui, Johnny...
SortirCasserole se décomposerait en AllerDevantPlacardBasGauche, OuvrirPortePlacardBasGauche, AttrapperCasserole, Reculer, FermerPlacardBasGauche, SeDeplacerVersEvier...


On peut ainsi stocker n'importe quelle méthode sur notre serveur RDF (avec Fuseki), ou sous forme de fichier rdf/owl téléchargeable.
ps : j'ai zappé pas mal de principes RDF, préfixe, etc... pour que ce soit plus clair à un non initié, mais l'intéressé pourra se rendre là : https://fr.wikipedia.org/wiki/Resource_Description_Framework ou là http://www.w3.org/TR/rdf-syntax-grammar/
 ou là en français : https://www.google.fr/webhp?sourceid=chrome-instant&ion=1&espv=2&ie=UTF-8#q=rdf%20francais 

Reste à créer une interface conviviale pour enregistrer, éditer, visualiser les méthodes...

inserer un fichier smagstructure.owl sur le serveur fuseki

D'après la doc de Fuseki (http://jena.apache.org/documentation/serving_data/)
sous Linux ou windows

0. Ruby doit être installé sur votre pc
1. créez votre fichier avec Protégé (http://fr.wikipedia.org/wiki/Prot%C3%A9g%C3%A9_(logiciel))
2. décompressez le répertoire Fuseki sur votre disque dur
3. rendre les fichiers s-put, s-get exécutables (chmod)
4. se placer dans le répertoire fuseki où se trouvent les fichiers s-put et s-get
5. y copier le fichier précédemment créé avec Protégé


Pour insérer des informations : 
ruby s-put http://fuseki-smag0.rhcloud.com/ds/data default smagstructure.owl

Pour récupérer les données :
ruby s-get http://fuseki-smag0.rhcloud.com/ds/data default

ceci insère/récupère des données dans le graphe par défaut "default", il est possible de créer vos propres graphes, pour "sectoriser" les informations en remplacant "default" par un nom de votre choix, faites attention à ne pas remplacer des infos déjà existantes dans un graphe !!! Dans le doute, vous pouvez laisser "default"


le resultat est ensuite visible là : http://fuseki-smag0.rhcloud.com/ds/query?query=select+*+where+%7B%3Fs+%3Fp+%3Fo%7D&output=xml&stylesheet=%2Fxml-to-html.xsl

inserer un nouveau projet doap au serveur Fuseki

Comment insérer un nouveau projet au serveur Fuseki du projet Smag0 :

Code source (App Inventor) et fichier pour Android au bas de cet article.

Dans le cadre Sparql Update de : http://fuseki-smag0.rhcloud.com/
 (selectionner "Control Panel" puis "ds" )

En remplacant test2 par le nom de votre projet

saisir :
 PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs:   <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX ex:   <http://example.org/>
PREFIX doap: <http://usefulinc.com/ns/doap#>
PREFIX smag:   <http://smag0.blogspot.fr/NS/>

INSERT DATA {
GRAPH <http://smag0.blogspot.fr/Projets>{
smag:test2 rdf:type doap:Project .

}
}


ou remplacez  "Titre Projet" "description Projet" par vos valeurs (attention, essayer de trouver un id unique, pour l'instant j'utilise le timestamp avec un "P" devant

PREFIX rdf:   <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
PREFIX rdfs:   <http://www.w3.org/2000/01/rdf-schema#>
PREFIX owl: <http://www.w3.org/2002/07/owl#>
PREFIX ex:   <http://example.org/>
PREFIX doap: <http://usefulinc.com/ns/doap#>
PREFIX smag:   <http://smag0.blogspot.fr/ns/smag0#>
PREFIX dc: <http://purl.org/dc/elements/1.1/>

INSERT DATA {
GRAPH <http://smag0.blogspot.fr/Projets>{
smag:id rdf:type smag:Projet .
smag:id dc:title  "Titre Projet" .
smag:id dc:description  "description Projet" .
}
}


SELECTION DES PROJETS : (dans le cadre Sparql Query)

select ?projet ?titre ?description where {
?projet <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://smag0.blogspot.fr/ns/smag0#Projet> .
?projet <http://purl.org/dc/elements/1.1/title> ?titre .
?projet <http://purl.org/dc/elements/1.1/description> ?description .
}
ORDER BY DESC(?projet)
LIMIT 100

résultat de la requete attendu


RECUPERER LES PROPRIETES DU PROJET DONT LE TITRE EST "SPHERO-CARTO"

PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX smag:   <http://smag0.blogspot.fr/ns/smag0#>

select * where {
?projet dc:title "Sphero-Carto" .
?projet ?propriete ?objet .
}

résultat attendu

idem avec Smag0 :

PREFIX dc: <http://purl.org/dc/elements/1.1/>
PREFIX smag:   <http://smag0.blogspot.fr/ns/smag0#>

select * where {
?projet dc:title "Smag0" .
?projet ?propriete ?objet .
}


résultat attendu



une application android créée avec App-Inventor permet d'inserer et de lire les informations RDF présentes sur ce serveur, elles sont récupérées au format JSON.

Cette démo est un premier test... juste pour la preuve du concept.
Maintenant je peux envoyer des infos sur mon serveur FUSEKI, et les récupérer sur mon smartphone Android. Utile pour envoyer des infos au système multi-agent Smag qui gère mon domicile.

ici se trouve le code source et l'apk : https://drive.google.com/folderview?id=0B0zEK4yLB5C6UUVsMWNkbDZ0WEU&usp=sharing

le fichier Projet.aia est à importer en tant que nouveau projet sur App-inventor : http://ai2.appinventor.mit.edu/

le fichier Projet.apk est prêt à l'emploi

deux fonctions sont incluses pour l'instant : Derniers projets et Ajout d'un projet (Connection internet /wifi activée nécessairement)
Parfois le serveur fuseki met du temps à démarrer. attendez 30 secondes et renouvelez en cas d'échec

!!!! première étape franchie !!! Yahou !!!!

Transformer du texte en rdf

http://wit.istc.cnr.it/stlab-tools/fred?text=smag0+is+a+project+.+its+goal+is+to+build+a+multi-agent+system+that+can+tidy+my+son%27s+room.+It+uses+a+pool+of+robot+like+PcDuinoRover+and+sphero.+PcDuinRover+has+a+camera+and+two+driving+whells.+Sphero+is+a+programmatic+ball.my+name%27s+David.+My+son%27s+name+is+Simon.+Simon+is+the+son+of+David.&prefix=fred%3A&namespace=http%3A%2F%2Fwww.ontologydesignpatterns.org%2Font%2Ffred%2Fdomain.owl%23&findrelations=true&wsd=true&format=application%2Frdf%2Bxml

Derniers test d'interface, parsing MindMap en RDF, parsing ontologie owl, et igeo avec Processing

​

 Smag0-test-processing-septembre-oct.zip

​
voir en détail le fichier Freemind dans le data du "mm_vers_rdf_28-10" pour plus de détails 

Re: livre-rdf-introduction

Pas facile d'ecrire un livre en CHOUET.

Le CHOUET cette nouvelle langue que le gouvernement veux nous imposer, par traduction primitive du langage OWL, une extension du langage RDF(Resource Deqcription Framework) afin d'être compris par les machines .

C'est certainement plus facile pour les jeunes, ceux de la génération Y et après, ceux qui ont l'habitude de communiquer par sms, par phrases courtes ou même par abréviations.

Ce langage sms qui généralement provoque chez leurs parents l'incrédulité et l'incompréhension la plus totale...

On croyait que ça s'arreterait rapidement... On avait passé le cap des premiers LOL et autres MDR. On croyait que c'était juste une mode entre "d'jeuns" comme le verlan que l'on avait infligé nous même à nos parents... On avait même accepté à l'époque de passer pour des "boulos" puisque les "has-been" étaient démodés depuis belle lurette . On était surpris par les dernieres tendances "hypster", qui d'après ce que j'en comprenais à l'époque ne se voulait d'aucune mode mais ressemblait un peu à toutes les autres sans accepter d'en avoir l'air...
Mais là... on atteignait les sommets :  le "français" était en phase de réécriture. Exit la grammaire et la conjugaison comme nous les avions apprises à l'école primaire...

Faute à qui ? au différents mooc sensés fournir gratuitement des cours à chacun permettant ainsi de se spécialiser dans un domaine précis sans aucune nécessité de maitriser les " matières généralistes" ...

On aurait dû s'en douter depuis longtemps... déjà quand Microsoft, Google et les autres se sont mis d'accord  pour adhérer aux normes du schemas.org. Deux dinosaures comme ça qui s'intéressent à une techno... ce n'est pas sans signification... Et le W3C en première ligne... ce n'est pas rien non plus !

Comment ça marche le CHOUET ?

Le pire c'est qu'il n'y a rien de plus simple et que l'on peut TOUT décrire, puisque RDF est un métalangage, on peut même s'appuyer sur les description faites par les autres pour éclaircir et préciser nos intentions. Par exemple, si je veux décrire une personne, je pourrais m'appuyer sur l'URI : https://schema.org/Person qui définit déjà un certain nombre de propriétés afférentes à une personne, comme par exemple "birthDate" qui correspondra à la date de naissance de cette personne et sera défini à cette adresse : https://schema.org/birthDate.

Ces URI (ou adresses uniques) peuvent être utilisées pour donner plus d'informations sur le contenu des pages web comme le préconise schemas.org, mais également pour décrire, partager, fusionner, et inférer sur des données disparates ou venant d'horizon ou de points de vue différents. Ces données peuvent être regroupées sous forme d'ontologies ( une ontologie représentant le vocabulaire d'un domaine et les relations entre ses concepts)

D'autres ont également senti le vent tourner et s'y sont mis à l'époque GoodRelations, par exemple pour le e-commerce s'appuyant eux -mêmes sur d'autres ontologies comme ou vocabulaires comme FOAF.

Comment utiliser le CHOUET ?

Comment je m'y suis mis ? tout bêtement... un enfant qui peut prononcer trois mots l'utilise déjà...

serveur Fuseki sur le pcduino

ça fait un bout que je suis pas passé.. M'enfin !!!
La livraison du pcDuino a pas mal tardé, ensuite les vacances...

Mais j'ai tout bien reçu (voir les articles précedents).
Quelques tests faits : installer vnc, librairie pyduino, brancher une caméra, une Led, (mon-club-elec.fr) , test des servos moteurs, et moteurs de déplacement (linksprite.com)...

Mais l'étape d'aujourd'hui concerne la mise en place d'un serveur fuseki afin de gérer la base de connaissance du robot

Fuseki :
sur le pcduino, decompresser le repertoire fuseki

Lancer fuseki au démarrage (modif du fichier autostart):
sudo geany /etc/xdg/lxsession/Lubuntu/autostart

ajouter une des deux  lignes suivante en fonction du mode de démarrage préféré :
- pour fuseki en mode non persistant pour faire des tests (en mémoire):
@/home/ubuntu/fuseki/fuseki-server --update --mem /ds

- pour fuseki en mode persistant pour que les données restent :
/home/ubuntu/fuseki/fuseki-server --update --loc=/home/ubuntu/fuseki/DEFAUT /ds
!!! pensez à créer le repertoire DEFAUT dans le repertoire fuseki et bien mettre un espace devant /ds qui défini le nom du dataset

(voir la doc de fuseki pour les différents modes de démarrage)


Le serveur Fuseki est accessible à l'adresse http://localhost:3030
on peut y uploader les fichiers de tests proposés sur le tutoriel Jena Sparql

aide pour construire les requetes Jena / Sparql : http://www.slideshare.net/rajighawi/java-and-sparql (diapo 5/26)

on peut même y accéder en mode distant, avec Processing et Jena
(modifier l'adresse : remplacez 10.42.0.1 par l'adresse de votre pcduino):


import java.io.Reader;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.query.ResultSet;
import javax.xml.transform.Result;
import com.hp.hpl.jena.query.QueryExecution;
import com.hp.hpl.jena.query.QueryExecutionFactory;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.query.ResultSetFormatter;
import com.hp.hpl.jena.ontology.OntModelSpec;


void setup() {
  /*
  http://host/dataset/query -- the SPARQL query endpoint.
   http://host/dataset/update -- the SPARQL Update language endpoint.
   http://host/dataset/data -- the SPARQL Graph Store Protocol endpoint.
   http://host/dataset/upload -- the file upload endpoint.
   */
  String endpoint = "http://10.42.0.1:3030/ds/query";
  String requete = "SELECT * WHERE {?S ?P ?O}";
  //String requeteJS = "SELECT ?x WHERE { ?x <http://www.w3.org/2001/vcard-rdf/3.0#FN> 'John Smith' }";
  // select-query
  QueryExecution qe = QueryExecutionFactory.sparqlService(endpoint, requete);
  //qe.setInitialBinding( );
  println (qe);
  ResultSet result = qe.execSelect();

  ////////////////////////:::::::::::::
 // Pour afficher les resultats deux solutions ResultSetFormatter.out(System.out, result); ou While / has next
   ResultSetFormatter.out(System.out, result);
  /*while (result.hasNext ()) {
    QuerySolution querySolution = result.next();
    println(querySolution);
  }*/
  //////////////////////////:::::::

  int numb = result.getRowNumber();
  println (numb);

  
}

void draw() {
}



ce sketch processing permet de visualiser les infos présentes sur le serveur Fuseki du pcduino. Pour une requête plus précise et notamment obtenir un graphe/model à la place d'un ResultSet, on devra utiliser Construst plutôt que Select qui retourne un tableau itérateur des solutions. http://jena.apache.org/tutorials/sparql_results.html

voir aussi les tutoriels Jena en français : http://jena.apache.org/tutorials/index.html

pour reinitialiser le serveur fuseki (effacer toutes les données) :
s-update --service http://localhost:3030/ds/update 'CLEARDEFAULT'

Réclamations, Doutes, Demandes

Au sujet de SMAG0, un robot qui range ma chambre.

On est partis pour... Ok, si je considère... allez... que dans 20 ans tout sera connecté dans ma maison et branché sur internet et commandable par mon smartphone (ou autre...)

Un paquet de questions se posent ...

Parce qu'un projet comme ça pose beaucoup de problème : éthique, sécurité, confidentialité, ...

Si vous avez des doutes, des peurs, des requêtes, des oppositions, quand au projet, ... c'est normal, j'ai aussi souvent peur de ce que je ne connais pas ...

On va tenter de  trouver des solutions à ces questions :

- Les robots vont-ils donner plus de chômage ?

- Vais-je perdre mon boulot ? 

- Qui est responsable d'un robot qui commettrait un délit ?

- Comment être sûr que mes informations personnelles ne sont pas diffusées sur le Net ?

- Comment désactiver un robot qui se trouverait dans ma maison ... et que j'y ferais des trucs que je n'ai pas envie qu'il voie ?

- Comment être certain que le robot dont j'ai besoin sera disponible au moment où j'en aurai besoin ? 

- Où vont-ils se ranger dans ma maison ?

- Comment le robot qui me fera le café va t-il savoir que le matin je mets deux sucres dans mon café et que le soir je n'en met qu'un ?

... et toutes les autres questions que vous pourriez-vous poser...

 Je vous invite au "Café des prudents, sceptiques & des opposants" : le café PSO, la discussion y est libre et plus elle sera virulente, plus on pourra approfondir les sujets et trouver des solutions.

Et juste à côté du café PSO, on va ouvrir le café SPO... le "Café des Sujets, Propriétés, & Objets", ce café parlera plus de technique et de la manière dont l'information peut être stockée : sous forme de triplet avec  :

un sujet, une propriété, un objet.
pour faire simple : 

<voiture> <couleur><rouge>

<david><age><37>

<pcduino Rover><type><robot>

...

d'autres cafés sont en train d'ouvrir leurs portes... Tenez... par exemple, je vois là-bas M. GéoTrouvetout... c'est lui qui tient le "café DIMB & DUMB" , le café des DIYeurs, des inventeurs, des makers et des bricoleurs, il y a également Mr Holon qui tient le "café SMA" , le café des Agents et des Multi-agents..., et d'autres encore... des boutiques, aussi où les inventeurs et fabricants exposent leurs projets... que du beau monde... il y a même un espace réservé pour l'utilisation du projet Smag0 par les enfants...

Vous trouverez également LA MAISON DES DEFIS : c'est l'endroit où l'on réalise les trucs qui ne sont normalement pas réalisables...
Et la place reste ouverte... n'importe qui peut se poser sur un banc et lancer un sujet de conversation, une idée, un problème...

Pour afficher le groupe de discussion en pleine page, suivez ce lien

Pourquoi du RDF ? pour jouer de la musique ?

- RDF ( resource description Framework) ? c'est un langage permettant de décrire des ressources d'un domaine... (voir wikipedia). Partageable, distribuable, interprétable par les machines....
- Ok ! c'est donc pour ça que tu veux absolument l'utiliser ?
- Oui, distribuable : donc les ressources sont décrites une fois et partagées entre les modules / robots , à condition de gérer la confidentialité des infos ... Et je me suis dit que je pouvais décrire avec la méthode Diamond qui est une méthode pour construire des systèmes multi-agents... J'en ai d'ailleurs fait une première version sur une autre page du blog, c'est diamond.owl. Et je suis en train d'essayer de la visualiser avec Processing.
Par extension, et si j'y arrive, je devrais pouvoir appliquer ce principe :
 [- visualiser / modifier les fichiers RDF/ontologies sous forme de graphes (Processing ? javascript + D3 ou jointjs)
- transmettre des infos à des machines (ordi/robot/module/agent) dans un format interpretable par elles.]
 à n'importe quelle méthode, comme une recette de cuisine, ou la procédure pour faire du café, pour ouvrir un placard ou y ranger les satanés légos qui trainenet.
- N'importe quelle méthode ou procédure ? Pourquoi pas une chanson, alors ? c'est comme une méthode ! Regarde : si on prend par exemple cette page http://www.francetabs.com/tablatures-partitions/brigitte/battez-vous-tab-guitare12488.html où on trouve les tablatures de Brigitte (désolé, je ne suis pas un crack en solfège, mais la suite doit être applicable aussi !)

ACCORDS

    

TABLATURE

d|———————————|——————————|————————————||
a|———————————|——————————|————2—0—————||
e|—12———11———|—10———9———|—0—3————3—0—|| clap-clap
   .tremolo-------------    ¬¬        


d|—–2————4———|——5————7———|—2—————————2——||
a|—–2————6———|—–5———–4———|—2———2—0———2——||
e|—––———––———|————––––––—|—0—3————–3—0—|| clap-clap
   .tremolo-------------     ¬¬


       Em       EmM7          Em7       Em6
Faites-vous la guerre pour me faire la cour
 Em
Maintenant battez-vous
  Em       EmM7    Em7    Em6
Soyez gangsters, soyez voyous
 Em
Maintenant battez-vous
      

(...) 
--Fin de l'extrait.

ça nous dit : à la basse : sur la corde de MI faire les notes 12, puis 11, puis 10, puis 9, puis 0, 3, corde de LA : 2, puis 0, re-corde de MI 3 puis 0, puis Clap-Clap.

Et tu dis que tu peux transmettre ça à une machine ?
- Bien sûr, le format rdf est fait pour ça ! Attend, je te montre ! D'abord , tu lance Protégé, et dedans, tu y décris tout ce dont tu as besoin pour ta méthode, ou tout autre chose ( On pourrais par exemple y décrire la procédure pour une opération chirurgicale ( ;-) Oh Coco... Private Joke !) .
Ensuite tu décris des Classes qui regroupent des éléments de même type, avec des sous classes éventuellement, puis des Entités (ou des Individuals) avec des propriétés.
Pour notre exemple, on pourra par exemple creer une classe Note, une classe Accord, une classe Corde, une classe Position, c'est à toi de décrire ton domaine comme tu le souhaite.
Deux personnes différentes pourront décrire le même domaine de deux manières différentes... ce n'est pas un problème, on pourra toujours rapprocher ensuite deux ontologies...
Dans diamond.owl, j'ai utilisé des Classes Etape et des propriétés first (pour indiquer la première Etape) puis des proprietes next pour lier les différents Individuals ou entités...
Un accord peut être décrit comme un ensemble de 3 notes...
On peut dans le même fichier décrire à la fois tous les instruments, et n'afficher (on ne jouer que les bonnes informations en fonction des requêtes).
Exemple qui ne fonctionnera pas en l'état mais possible :  SELECT Accord WHERE {?Accord ?Instrument ?Guitare} ORDERBY ?Ordre

Essaie Protégé,  si tu veux un exemple : tu peux récupérer diamond-first.owl, et si tu veux des infos sur comment utiliser Protégé pour décrire un domaine, tu peux aller voir tout en bas de cet article : http://smag0.blogspot.fr/2014/03/creer-une-interface-pour-visualiser-les.html et récupérer le tutoriel Pizza-Gloria

+++ On peut même certainement s'amuser avec les machines à états finis dans une Ontologie... à voir : http://www.w3.org/TR/2014/CR-scxml-20140313/