<?xml version="1.0" encoding="utf-8"?>
<?xml-stylesheet type="application/xml" href="memoires.xsl"?>
<!DOCTYPE memoires SYSTEM "memoires.dtd">
<memoires xmlns:h="http://www.w3.org/1999/xhtml/">
  <introduction>
    Vous avez à réaliser, par groupe de 1 ou 2, un mini-mémoire sur l'un
    des sujets suivants. Certains sujets ne pouvant être effectués que
    par un unique groupe, les sujets seront attribués sur la règle du
    « premier demandé, premier servi ». Veuillez donc communiquer le plus
    tôt possible à Pierre Senellart (pierre.senellart@telecom-paristech.fr)
    la composition des groupes et au moins deux souhaits parmi la liste
    suivante. L'affectation définitive vous sera communiquée par retour
    de mail. Les mémoires seront soutenus les 17 et 20 février 2008.
    L'enseignant associé à chaque sujet est uniquement à contacter
    si vous avez des questions précises à lui poser sur le sujet.
  </introduction>
  <memoire enseignant="luc" type="design">
    <titre>Méthodes d’indexation pour des données stockées sur des
      mémoires de type FLASH</titre>
    <enonce>
      <h:p>Les mémoires FLASH ont des caractéristiques très
        particulières en termes d’accès, de programmation (écriture) ou
        d’effacement (nécessaire avant l’écriture) rendant complexe le
        développement de système de gestion de bases de données utilisant
        ce média de stockage.</h:p>
      <h:p>Après une étude approfondie des ces mémoires, vous proposerez le
        design d’une méthode d’indexation permettant (sous certaines
        hypothèses à définir) d’obtenir de bonnes performances pour accéder
        à une table.</h:p>
      <h:p>La FLASH est une mémoire stable qui possède des caractéristiques
        assez particulières :</h:p>
      <h:ul>
        <h:li>Lecture rapide (25 microsecondes pour une page de 2
          Ko)</h:li>
        <h:li>écriture assez rapide (300 microsecondes /page)</h:li>
        <h:li>effacement gros grain et long (2 millisecondes /bloc de 128
          Ko)</h:li>
      </h:ul>
      <h:p>Il est impossible de mettre à jour une donnée sans effacer le bloc
        qui la contient.</h:p>
      <h:p>Le sujet consiste en :</h:p>
      <h:ol>
        <h:li>étude des mémoires flash (docs à chercher sur le
          web)</h:li>
        <h:li>définition du problème d’indexation de données en
          flash</h:li>
        <h:li>proposition d'une solution</h:li>
      </h:ol>
      <h:p>Hypothèses :</h:p>
      <h:ol>
        <h:li>
          On dispose d'une petite quantité de mémoire stable (qui ne s'efface
          pas sans courant) avec des bonnes propriétés (lecture/écriture
          rapide et grain fin)</h:li>
        <h:li>La BD est en append only (on ne fait que rajouter des
          données)</h:li>
      </h:ol>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="implémentation">
    <titre>Outil didactique pour la compréhension des mécanismes de
      contrôle de concurrence</titre>
    <enonce>
      <h:p>Il s’agit de créer un petit outil simulant le comportement
        d’un SGBD au niveau du contrôle de concurrence. Le SGBD gèrera 1
        ou 2 données seulement. Deux fenêtres permettront d’entrer des
        ordres, simulant deux utilisateurs distincts. Suivant la
        configuration (avec ou sans contrôle, degré d’isolation, mode
        multiversion), on simulera le comportement du SGBD et on
        affichera l’état des variables.</h:p>
      <h:p>A chaque entrée d’un ordre sur l’une ou l’autre des fenêtres,
        l’outil affichera le comportement du SGBD (commande acceptée,
        blocage, erreur) avec l’état des données, des verrous etc.</h:p>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="étude bibliographique">
    <titre>Outils de Gestion de la mémoire dans Oracle 9i</titre>
    <enonce>
      <h:p>Il s’agit de lire, comprendre et expliquer en détail les
        mécanismes mis en œuvre dans Oracle pour gérer la mémoire lors de
        l’exécution de Requêtes. Ce travail est basé sur un l’article
        suivant et peut être complété par des recherches sur le
        WEB :<h:br/>Benoît Dageville, Mohamed Zaït: SQL Memory Management in
        Oracle9i. VLDB 2002 <h:a
          href="http://www.vldb.org/conf/2002/S29P03.pdf">http://www.vldb.org/conf/2002/S29P03.pdf</h:a>
      </h:p>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="expérimentation">
    <titre>Expérimentation de l'optimisation Oracle</titre>
    <enonce><h:p>Vous créerez ou récupérerez une base exemple sur Oracle (je
        peux vous en fournir une). Vous imaginerez alors une requête
        suffisamment complexe et intéressante pour montrer l'impact du
        choix de différents plans d'exécution sous Oracle. Pour cela, vous
        utiliserez la fonction "explain plan" d'oracle, des mesures de
        performances et influencerez les choix de l'optimiseur par des
        "hints" (cf. Cours).</h:p>
      <h:p>Dans le rapport, vous détaillerez et expliquerez les différents
        plans et performances obtenus.</h:p>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="implémentation">
    <titre>Utilisation du package OracleObfuscationToolkit et
      JavaCrypto</titre>
    <enonce><h:p>Il s’agit d’implanter sous oracle une petite application
        JAVA simpliste permettant d’insérer des données dans une table et
        d’interroger cette dernière en SQL (sélections simples,
        mono-relation, mono-prédicat ex. Select xxx, yyy From REL where x
        comp constante où comp est ‘=’, ‘&lt;’ ou ‘>’). 
      </h:p>
      <h:p>La difficulté provient du fait que les données doivent être
        stockées chiffrées.
        Pour cela, vous implanterez et comparerez deux méthodes :
      </h:p>
      <h:dl>
        <h:dt>OracleObfuscationToolkit</h:dt>
        <h:dd>L’application manipule des données
          en clair, les données sont cryptées et décryptées sous Oracle
          grâce à OracleObfuscationToolkit</h:dd>
        <h:dt>JavaCrypto</h:dt>
        <h:dd>L’application insère des données déjà cryptées dans la
          table sous Oracle. Pour l’interrogation, on peut imaginer une
          collaboration entre Oracle et le client</h:dd>
      </h:dl>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="implémentation">
    <titre>Algorithmes de jointure</titre>
    <enonce><h:p>Il s’agit d’implanter quelques algorithmes de jointure
        pour joindre deux tables avec une quantité de mémoire variable
        (cf. cours). On pourra par exemple (au choix) :</h:p>
      <h:ol>
        <h:li>implanter et comparer le Block Nested Loop Join et le
          Hash Join
        </h:li>
        <h:li>Le Hash Join et le Sort Merge Join</h:li>
        <h:li>Le Hash Join classique et le Hash Join non
          bloquant</h:li>
      </h:ol>
      <h:p>Vous travaillerez avec deux tables fournies (ex. Client /
        Commande) et devrez réaliser la jointure avec les algorithmes
        programmés. Le programme prendra en entrée une quantité de
        mémoire donnée (ou un intervalle) et fournir en sortie :</h:p>
      <h:ul>
        <h:li>Le temps d’exécution</h:li>
        <h:li>Le nombre d’entrées / sorties</h:li>
        <h:li>La mémoire utilisée</h:li>
      </h:ul>
      <h:p>Vous pouvez vous aider de bibliothèques java existantes (ex.
        Hachage, tri)</h:p>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="implémentation">
    <titre>Outil didactique pour l'explication du modèle itérateur.
      Implémentation d'un mini moteur d'exécution basé sur le modèle
      itérateur</titre>
    <enonce>
      <h:p>Il s'agit d'implanter quelques opérateurs de base (au minimum,
        la sélection, la projection et la jointure), et, grâce au modèle
        itérateur vu en cours, d'exécuter une requête écrite sous forme
        algébrique. </h:p>
      <h:ul>
        <h:li>On créera "en dur" 3 relations (stockées sous la forme de
          3fichiers) : R(RID, RA1, RA2) , S (SID, RID, SA1, SA2) et T
          (TID, SID, TA1, TA2) où tous les attributs sont des entiers
          (pour simplifier). RID, SID et TID sont des identifiants de
          tuples (attention à faire des relations cohérentes). RA1, RA2,
          SA1, SA2, TA1, TA2 sont des entiers et vous mettrez les valeurs
          qui vous arrangent (ça peut être utile que ces valeurs ne
          soient pas aléatoire pour montrer que l'on puisse vérifier le
          résultat des requêtes – exemple RA1 = RID, RA2 = RID*2, SA1 =
          RID*SID, SA2 = RID*SID*2, etc..)</h:li>
        <h:li>l'utilisateur entrera une requête sous forme algébrique,
          par exemple : 
          project(join (R, select(S, SA2>10), R.RID = S.RID), R.RID, SA2)
          qui correspond à la requête :
          select R.RID, SA2 from R, S where R.RID = S.RID and SA2 >
          10</h:li>
        <h:li>L'outil calculera alors le résultat en produisant des
          traces permettant de comprendre comment cela s'exécute (i.e.,
          liste des appels à open, next et close)</h:li>
      </h:ul>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="étude de produits et/ou étude bibliographique">
    <titre>Outil(s) de tuning automatique</titre>
    <enonce>Vous devez chercher, installer et tester un outil de tuning
      automatique (e.g., SQL SERVER DTA ou celui d'Oracle, ou …) dans le
      cas où ces derniers sont disponibles et gratuits. Dans le cas
      contraire, l'étude se limitera à une étude bibliographique de
      documents décrivant un ou plusieurs de ces produits. </enonce>
  </memoire>
  <memoire enseignant="luc" type="design et/ou implémentation">
    <titre>Séquentialisation des IO aléatoires sur mémoire Flash</titre>
    <enonce>
      <h:p>Il s’agit de spécifier (plus raisonnable) ou d’implanter (plus
        difficile) un module s’intercalant entre l’OS et un composant
        FLASH permettant de séquentialiser les entrées sorties.
      </h:p>
      <h:p>Typiquement, une clé USB obtient de très bon temps d’accès
        (e.g., 1 à 3 ms) en lecture (séquentielle ou aléatoire) et en
        écriture séquentielle. Les écritures aléatoires sont par contre
        terriblement coûteuses (e.g. 200 ms). Le même comportement se
        vérifie sur un SSD (0,1 ms en lecture et écriture séquentielle)
        contre 5 à 20 ms en écriture aléatoire.
      </h:p>
      <h:p>L’idée est de réaliser une couche intermédiaire permettant de
        transformer les écritures aléatoires  en écritures séquentielles
        quitte à transformer les lectures séquentielles en lectures
        aléatoires en gérant des structures de translation entre une
        adresse « logique » et une adresse « physique » (en fait le
        composant FLASH gère lui-même une telle translation mais à un
        granule trop important (e.g., 512 KB)).
      </h:p>
      <h:p>Vous ferez soit le design de cette solution, en prenant soin
        de considérer le cas de l’arrachement du composant ;
        c'est-à-dire, qu’il faut que votre structure qui serait a priori
        en RAM puisse être reconstruite dans un temps raisonnable lorsque
        le composant est connecté de nouveau.
      </h:p>
      <h:p>Si vous faites une implantation, vous pouvez considérer que
        l’arrachement se fait de manière « propre », i.e., qu’une
        procédure ‘éjecter’ existe et permet de sauvegarder la structure.
        Un petit scénario de démo devra aussi être implanté.
      </h:p>
    </enonce>
  </memoire>
  <memoire enseignant="luc" type="expérimentation">
    <titre>Benchmarking de disques durs</titre>
    <enonce><h:p>uFLIP est un benchmark crée pour mesurer et observer les
        performances des mémoires FLASH – voir <h:a
          href="http://www.uflip.org/">http://www.uflip.org/</h:a>. En fait, il
        est assez général pour capturer le comportement de plusieurs
        composants de stockage.</h:p>
      <h:p>Le but de ce projet est de comprendre uFLIP (toutes les
        informations sont sur le site web) et d’appliquer le benchmark
        sur un disque dur (attention, toutes les données sont détruites).
      </h:p>
      <h:p>Le résultat attendu est :</h:p>
      <h:ol>
        <h:li>Méthodologie de mesure employée (elle sera certainement
          différente)
        </h:li>
        <h:li>Analyse des résultats</h:li>
        <h:li>Discussion, critiques, propositions (ce qui manque et ce
          qui n’a pas d’intérêt)
        </h:li>
      </h:ol>
    </enonce>
  </memoire>
  <memoire enseignant="bogdan" type="étude bibliographique">
    <titre>Le SGBD réparti Mariposa</titre>
    <enonce>
      <h:p>Il s'agit d'étudier une approche assez non conventionnelle
        pour la gestion de données dans un SGBD reparti. Le système
        Mariposa, développé par le groupe BD de l'Université de Berkeley,
        essaie d'employer des principes économiques dans les stratégies
        d'évaluation repartie de requêtes.</h:p>
      <h:p>Il s'agit de lire les documents qui donnent les grandes
        principes de ce système, comprendre et expliquer ces
        particularités, et peut être essayer de comprendre pourquoi
        l'approche de Mariposa n'a pas eu l'impact attendu en industrie.
      </h:p>
      <h:p>Le point de départ est la page du projet,
        <h:a
          href="http://mariposa.cs.berkeley.edu">http://mariposa.cs.berkeley.edu</h:a>.</h:p>
    </enonce>
  </memoire>
  <memoire enseignant="bogdan" type="étude bibliographique">
    <titre>Bases de Données « Hippocratiques »</titre>
    <enonce>
      <h:p>
        Les BD Hippocratiques (ou d'Hippocrate) proposent un ensemble de
        principes fondateurs et de mécanismes pour préserver les données
        privées des individus dans une base de données.
      </h:p>
      <h:p>Les principes hippocratiques ont été introduits par le groupe
        de recherche BD de IBM Almaden (le même endroit qui a donné les
        BD relationnelles).
      </h:p>
      <h:p>Il s'agit d'étudier cette approche pour la gestion de données
        privées: lire les documents qui donnent les principes fondateurs,
        comprendre et expliquer les particularités, essayer de comprendre
        les enjeux et les difficultés pour la mise en pratique.
      </h:p>
      <h:p>Le point de départ est la page du projet,
        <h:a
          href="http://www.almaden.ibm.com/cs/projects/iis/hdb/hdb_projects.shtml">http://www.almaden.ibm.com/cs/projects/iis/hdb/hdb_projects.shtml</h:a>.
      </h:p>
    </enonce>
  </memoire>
  <memoire enseignant="bogdan" type="expérimentation">
    <titre>Utilisation de Incognito: k-anonymity  pour la confidentialité
      des individus</titre>
    <enonce>
      <h:p>Le but de ce projet et de tester le logiciel Incognito:</h:p>
      <h:ol>
        <h:li>Téléchargez le logiciel d'anonymisation de données
          Incognito, à partir de l'URL
          <h:a
            href="http://www.cs.cornell.edu/database/privacy">http://www.cs.cornell.edu/database/privacy</h:a></h:li>
        <h:li>Installez et configurez ce logiciel (le SGBD IBM DB2 est
          nécessaire, disponible en version « trial »)</h:li>
        <h:li>Définissez un schéma pour les relations qui seront
          anonymisées (il faut définir une schema-étoile qui donne les
          hiérarchies de généralisation des attributs)</h:li>
        <h:li>Remplissez les tables (il est envisageable d'utiliser un
          générateur de tuples)</h:li>
        <h:li>Utilisez Incognito pour traiter les données sensibles.
          Tous les documents nécessaires (et beaucoup plus sur ce thème
          de recherche) se trouve à l’URL
          <h:a
            href="http://www.cs.cornell.edu/database/privacy/">http://www.cs.cornell.edu/database/privacy/</h:a>.
        </h:li>
      </h:ol>
      <h:p>Extension possible pour ce projet: Le coût en temps de
        calcul peut être assez important (trouver la solution optimale
        est un problème NP-difficile). Il serait donc intéressant
        d'implémenter un des algorithmes d'approximation qui ont été
        proposé pour k-anonymity, et de comparer les performances.
      </h:p>
    </enonce>
  </memoire>
  <memoire enseignant="bogdan" type="étude bibliographique">
    <titre>Généralisation de données pour protéger la confidentialité
      des individus</titre>
    <enonce>
      <h:p>Il s’agit d’étudier les différentes techniques proposées pour
        la généralisation de données (k-anonymity, l-diversity,
        t-closeness, m-invariance, etc) et de présenter dans une étude
        comparative leurs avantages et désavantages.</h:p>
    </enonce>
  </memoire>
  <memoire enseignant="bogdan" type="étude bibliographique">
    <titre>Le SGBD KBD+</titre>
    <enonce>
      <h:p>Il s’agit d’étudier un SGBD qui présente plusieurs
        particularités (in-memory, column-based), utilisé souvent dans
        la gestion de données de type « time series » (e.g.,
        applications financières). Il s’appuie sur un langage de
        manipulation Q (extension du langage K), qui est assez différent
        de SQL. 
      </h:p>
      <h:p>Un possible point de depart et la page Wikipedia
        <h:a
          href="http://en.wikipedia.org/wiki/K_programming_language">http://en.wikipedia.org/wiki/K_programming_language</h:a>.
      </h:p>
    </enonce>
  </memoire>
  <memoire enseignant="hubert" type="implémentation">
    <titre>Implémentation du benchmark TPC-E</titre>
    <enonce>
      <h:p>
        TPC Benchmark™ E (TPC-E) is a new On-Line Transaction Processing
        (OLTP) workload being developed by the TPC. The TPC-E benchmark
        simulates the OLTP workload of a brokerage firm. The focus of
        the benchmark is the central database that executes transactions
        related to the firm’s customer accounts. Although the underlying
        business model of TPC-E is a brokerage firm, the database
        schema, data population, transactions, and implementation rules
        have been designed to be broadly representative of modern OLTP
        systems. (cf. <h:a
          href="http://www.tpc.org/tpce/tpc-e.asp">http://www.tpc.org/tpce/tpc-e.asp</h:a>)</h:p>
      <h:p>Le sujet est d'implémenter ce benchmark sur un SGBD
        centralisé (par exemple Oracle)</h:p>
    </enonce>
  </memoire>
  <memoire enseignant="hubert" type="design et implémentation">
    <titre>Implémentation d'un index en mémoire</titre>
    <enonce>Le but est d'implémenter un index en mémoire aussi
      performant que possible, dans le cadre du concours de
      programmation de SIGMOD 2009. cf. <h:a
        href="http://db.csail.mit.edu/sigmod09contest/">http://db.csail.mit.edu/sigmod09contest/</h:a>.</enonce>
  </memoire>
  <memoire enseignant="talel" type="expérimentation">
    <titre>Benchmarking de requêtes XQuery composées.</titre>
    <enonce>Le but de ce projet est d’analyser les capacités
      d’optimisation des interpréteurs XQuery actuels dans le cas
      particulier des requêtes composées (des requêtes qui s’appuient
      sur un résultat intermédiaire calculé par une sous-requêtes). Dans
      certains cas, les requêtes composées peuvent être réécrites sous
      forme plus simple et plus rapide à évaluer. Un exemple de requête
      vous sera fourni et le travail qui vous est demandé consiste à
      tester cette requête, dans sa forme composée puis dans sa forme
      simplifiée sur au moins deux interpréteurs XQuery de votre choix
      (Galax, eXist, Saxon, MonetDB, Berlkeley DB XML, etc.). Les tests
      doivent être réalisés sur des documents sources de différentes
      tailles. Pour cela, on utilisera le générateur de documents XML du
      benchmark Xmark. Les résultats obtenus doivent être commentés et
      illustrés par des courbes montrant les gains de temps éventuels,
      entre la requête composée et la requête simplifiée, et les
      différences entre les interpréteurs choisis.
    </enonce>
  </memoire>
  <memoire enseignant="talel" type="expérimentation">
    <titre>Requêtes continues : évaluation de l’outil Oracle CEP (Oracle
      Complexe Event Processing)
    </titre>
    <enonce>
      <h:p>Le développement des réseaux informatiques a facilité
        l’échange d’information et l’émergence de sources de données
        continues (cotations d’actions, réseaux de capteurs, etc.). Les
        flux de données échangés dans ce cas sont conséquents, leur
        traitement peut être complexe et leur stockage est souvent
        inutile (on veut juste en extraire des informations
        <h:em>online</h:em>). Des
        langages de requêtes continues ont été proposés pour répondre à
        ce besoin et Oracle vient de proposer une implantation de l’une
        de ces solutions : Oracle CEP.</h:p>
      <h:p>Description donnée sur le site Oracle : “Today's IT
        environments generate continuous streams of data for everything
        from monitoring financial markets and network performance, to
        business process execution and tracking RFID tagged assets.
        Oracle Complex Event Processing (Oracle CEP) provides a rich,
        declarative environment for developing event processing
        applications to improve the effectiveness of your business
        operations. Oracle CEP can process multiple event streams to
        detect patterns and trends at real time and provide enterprises
        the necessary visibility via Oracle Business Activity Monitoring
        (Oracle BAM) to capitalize on emerging opportunities or mitigate
        developing risks.”
      </h:p>
      <h:p><h:strong>Travail demandé :</h:strong> Tester, analyser et
        évaluer cet outil sur un jeu de données de votre choix.
      </h:p>
      <h:p><h:strong>Références : </h:strong></h:p>
      <h:ol>
        <h:li>description sur le site Oracle :
          <h:a
            href="http://www.oracle.com/technologies/soa/complex-event-processing.html">http://www.oracle.com/technologies/soa/complex-event-processing.html</h:a></h:li>
        <h:li>Outil à télécharger :
          <h:a
            href="http://www.oracle.com/technology/software/products/cep/index.html">http://www.oracle.com/technology/software/products/cep/index.html</h:a></h:li>
        <h:li>Article de recherche décrivant le langage de requêtes CQL :
          <h:a
            href="http://ilpubs.stanford.edu:8090/758/1/2003-67.pdf">http://ilpubs.stanford.edu:8090/758/1/2003-67.pdf</h:a></h:li>
      </h:ol>
    </enonce>
  </memoire>
  <memoire enseignant="talel" type="étude bibliographique">
    <titre>TrustRank</titre>
    <enonce>
      <h:p>Il s’agit de lire, comprendre et expliquer en détail les
        principes et le fonctionnement de l’algorithme de lutte contre
        les spams TrustRank adoptés par Google.  Ce travail est basé
        sur un l’article suivant et peut être complété par des
        recherches sur le WEB : <h:br/>
        Zoltan Gyöngyi, Hector Garcia-Molina, Jan Pedersen :
        Combating Web Spam with TrustRank.
        <h:a
          href="http://www.vldb.org/conf/2004/RS15P3.PDF.">http://www.vldb.org/conf/2004/RS15P3.PDF</h:a>.
      </h:p>
    </enonce>
  </memoire>
  <memoire enseignant="talel" type="étude bibliographique">
    <titre>Déduplication de données (Entity Resolution)
    </titre>
    <enonce>
      <h:p>La déduplication consiste à déterminer dans une base de
        données quelles couples d’enregistrements représentent une
        même entité du monde réel. Ce problème est important dans de
        nombreux domaines (gestion de la relation client, fédération
        de données dans les systèmes hétérogènes, extraction de
        connaissances à partir du web, etc.). Plusieurs solutions ont
        été proposées récemment et le travail demandé consiste à
        lire, comprendre et expliquer en détail une de ces solutions.
        Ce travail peut être basé sur l’un des articles suivants et
        peut être complété par des recherches sur le web :
        <h:br/>

        Omar Benjelloun, Hector Garcia-Molina, David Menestrina, Qi
        Su, Steven Euijong Whang, Jennifer Widom. Swoosh: a generic
        approach to entity resolution.
        <h:a
          href="http://ilpubs.stanford.edu:8090/708/1/2005-5.pdf">http://ilpubs.stanford.edu:8090/708/1/2005-5.pdf</h:a>
        <h:br/>
        Parag Singla, Pedro Domingos : Entity Resolution with Markov
        Logic.
        <h:a
          href="http://www.cs.washington.edu/homes/pedrod/papers/icdm06.pdf">http://www.cs.washington.edu/homes/pedrod/papers/icdm06.pdf</h:a>
        <h:br/>
        Indrajit Bhattacharya, Lise Getoor : Collective Entity
        Resolution In Relational Data.
        <h:a
          href="http://www.cs.washington.edu/homes/pedrod/papers/icdm06.pdf">http://linqs.cs.umd.edu/basilic/web/Publications/2007/bhattacharya:tkdd07/bhattacharya-tkdd.pdf</h:a>
      </h:p>
    </enonce>
  </memoire>
  <memoire enseignant="pierre" type="développement">
    <titre>XSLT pour transformer des données numériques</titre>
    <enonce>
  Mise en place d'un site Web permettant d'afficher des données (numériques)
  de diverses manières graphiques (au
    moins : histogrammes, courbes, diagrammes  camembert ), en utilisant
    SVG (Scalable Vector Graphics). On rappelle
    que les versions récentes des navigateurs Opera et Firefox supportent
    relativement bien le SVG; en cas de souci, on pourra
    utiliser un outil comme rsvg pour convertir les images vectorielles
    SVG en images bitmap PNG. Les données devront
    également être présentées sous forme de tableaux HTML ou XHTML.
    L'application devra intégrer un moyen de convertir
    des données au format CSV (Comma-Separated Value), qui pourront être
    par exemple issues d'un tableur, vers un format
    XML à définir. L'application développée devra se baser sur XSLT (au choix, 1.0 ou
  2.0), mais vous pouvez mettre en œuvre d'autres
technologies.</enonce>
</memoire>
<memoire enseignant="pierre" type="implémentation et expérimentation">
    <titre>Application de la déduplication à des données réelles</titre>
  <enonce>
    <h:p>La déduplication consiste à déterminer dans une base de
      données quelles couples d’enregistrements représentent une même
      entité du monde réel. Ce problème est important dans de nombreux
      domaines (gestion de la relation client, fédération de données dans
      les systèmes hétérogènes, extraction de connaissances à partir du
      web, etc.).</h:p>
    <h:p>Le but du projet consiste à appliquer des techniques de
      déduplication détaillées dans le document de référence qui suit, à
      choisir de manière appropriée, à
      une base de données réelle de vente d'album de musique, fournie par
      l'enseignant sur demande.<h:br/>
      Ahmed K. Elmagarmid, Panagiotis G. Ipeirotis, Vassilios S.
      Verykios: Duplicate Record Detection: A Survey. IEEE Trans. Knowl.
      Data Eng. 19(1): 1-16 (2007). <h:a
        href="http://pages.stern.nyu.edu/~panos/publications/tkde2007.pdf">http://pages.stern.nyu.edu/~panos/publications/tkde2007.pdf</h:a></h:p>
  </enonce>
</memoire>
  <memoire enseignant="pierre" type="étude de produits">
    <titre>MySQL vs PostgreSQL</titre>
    <enonce>
      <h:p>MySQL et PostgreSQL sont deux SGBD libres très populaires.
        Le but de ce projet est de faire une étude comparative de ces
        deux systèmes suivant les axes suivants</h:p>
      <h:ul>
        <h:li>Fonctionnalités</h:li>
        <h:li>Simplicité d'utilisation et de mise en place</h:li>
        <h:li>Performance (à tester avec un jeu de données et des
          requêtes dont il vous faudra décider, aussi varié que
          possible).</h:li>
      </h:ul>
      <h:p>Vous vous servirez de l'analyse effectuée pour émettre des
        recommandations sur les contextes dans lequel le choix de l'un de
        ces produits s'impose, et vous terminerez en comparant brièvement
        ces deux produit à un SGBD commercial comme Oracle.</h:p>
    </enonce>
</memoire>
<memoire enseignant="pierre" type="étude bibliographique">
  <titre>SGBD probabilistes</titre>
  <enonce><h:p>Un SGBD probabiliste permet de stocker des informations avec un
    degré d'incertitude, et est utile dans un grand nombre de contexte
    (données bruitées, intégration de données, observations non fiables,
    etc.). Le but de ce projet est de faire une étude comparative de deux
    SGBD probabilistes: Trio et MayBMS, respectivement développées à
    Stanford et à Cornell. Il s'agit de parcourir la littérature
    correspondante afin de comprendre les différences d'approche, et
    d'expérimenter les deux systèmes (librement téléchargeables).<h:br/>
<h:a
  href="http://infolab.stanford.edu/trio/">http://infolab.stanford.edu/trio/</h:a>
<h:br/><h:a
  href="http://www.cs.cornell.edu/bigreddata/maybms/">http://www.cs.cornell.edu/bigreddata/maybms/</h:a></h:p>
</enonce>
</memoire>
  <enseignant id="talel">
    <name>Talel Abdessalem</name>
    <homepage>http://www.infres.enst.fr/~talel/</homepage>
  </enseignant>
  <enseignant id="bogdan">
    <name>Bogdan Cautis</name>
    <homepage>http://www.infres.enst.fr/~bogdan/</homepage>
  </enseignant>
  <enseignant id="luc">
    <name>Luc Bouganim</name>
    <homepage>http://www-smis.inria.fr/~bouganim/WebSitePerso/</homepage>
  </enseignant>
  <enseignant id="pierre">
    <name>Pierre Senellart</name>
    <homepage>http://pierre.senellart.com/</homepage>
  </enseignant>
  <enseignant id="hubert">
    <name>Hubert Naacke</name>
    <homepage>http://www-poleia.lip6.fr/~naacke/</homepage>
  </enseignant>
</memoires>

