Memoized zipper-based attribute grammars and their higher order extension

Attribute grammars are a powerfull, well-known formalism to implement and reason about programs which, by design, are conveniently modular. In this work we focus on a state of the art zipper-based embedding of classic attribute grammars and higher-order attribute grammars. We improve their execution performance through controlling attribute (re)evaluation by means of memoization techniques. We present the results of our optimizations by comparing their impact in various implementations of different, well-studied, attribute grammars and their Higher-Order extensions. (C) 2018 Elsevier B.V. All rights reserved.- (undefined

Constructing Hybrid Incremental Compilers for Cross-Module Extensibility with an Internal Build System

Context: Compilation time is an important factor in the adaptability of a software project. Fast recompilation enables cheap experimentation with changes to a project, as those changes can be tested quickly. Separate and incremental compilation has been a topic of interest for a long time to facilitate fast recompilation. Inquiry: Despite the benefits of an incremental compiler, such compilers are usually not the default. This is because incrementalization requires cross-cutting, complicated, and error-prone techniques such as dependency tracking, caching, cache invalidation, and change detection. Especially in compilers for languages with cross-module definitions and integration, correctly and efficiently implementing an incremental compiler can be a challenge. Retrofitting incrementality into a compiler is even harder. We address this problem by developing a compiler design approach that reuses parts of an existing non-incremental compiler to lower the cost of building an incremental compiler. It also gives an intuition into compiling difficult-to-incrementalize language features through staging. Approach: We use the compiler design approach presented in this paper to develop an incremental compiler for the Stratego term-rewriting language. This language has a set of features that at first glance look incompatible with incremental compilation. Therefore, we treat Stratego as our critical case to demonstrate the approach on. We show how this approach decomposes the original compiler and has a solution to compile Stratego incrementally. The key idea on which we build our incremental compiler is to internally use an incremental build system to wire together the components we extract from the original compiler. Knowledge: The resulting compiler is already in use as a replacement of the original whole-program compiler. We find that the incremental build system inside the compiler is a crucial component of our approach. This allows a compiler writer to think in multiple steps of compilation, and combine that into a incremental compiler almost effortlessly. Normally, separate compilation \`a la C is facilitated by an external build system, where the programmer is responsible for managing dependencies between files. We reuse an existing sound and optimal incremental build system, and integrate its dependency tracking into the compiler. Grounding: The incremental compiler for Stratego is available as an artefact along with this article. We evaluate it on a large Stratego project to test its performance. The benchmark replays edits to the Stratego project from version control. These benchmarks are part of the artefact, packaged as a virtual machine image for easy reproducibility. Importance: Although we demonstrate our design approach on the Stratego programming language, we also describe it generally throughout this paper. Many currently used programming languages have a compiler that is much slower than necessary. Our design provides an approach to change this, by reusing an existing compiler and making it incremental within a reasonable amount of time

Generating incremental attribute evaluators

In onze maatschappij wordt tegenwoordig veel met software, dat wil zeggen com- puterprogramma's, gewerkt. Denk daarbij niet alleen aan tekstverwerkers, maar ook aan software in geldautomaten, videorecorders en het administratiesysteem van de scus. Software moet geschreven worden. Programmeurs schrijven software in zoge- heten hogere programmeertalen, waarvan Pascal, C, Basic, Cobol en Fortran de bekenste zijn. Zulke programmeertalen nemen tijdrovende, saaie en administratieve taken verbonden aan het programmeren, uit handen. Echter, computers \begrijpen" hogere programmeertalen niet, zij moeten ge?n- strueerd worden in een zogeheten machinetaal. Om een hogere programmeertaal naar machinetaal te vertalen zijn er speciale computerprogramma's in omloop, zogeheten compilers. Met andere woorden, compilers vormen een vitale schakel in het productieproces van software. Een compiler zet een zogeheten bronprogramma, geschreven in een specieke hogere programmeertaal, om naar een zogeheten doel programma in een specieke machinetaal. Men spreek dan bijvoorbeeld ook van een \Pascal compiler voor een DOS computer". De kwaliteit van het doelprogramma is niet alleen afhankelijk van de kwaliteit van het bronprogramma, maar ook van de kwaliteit van de gebruikte compiler. Compilers zijn grote, ingewikkelde programma's, die ook geschreven moeten worden. Dit proces wordt ondersteund door compiler-generatoren. Tijdens mijn?192 Samenvatting boter melk 30 10 2,50 1,25 item aantal prijs a b c d 1 23 4 b2 b3 x c2 c3 x b4+c4 b2+c2 boter melk 30 10 2,50 1,25 25,00 52,50 item aantal prijs a b c d 1 23 4 40 77,50 a. Invoer b. Uitvoer Figuur 2. Een rekenblad voor de melkboer vierjarig onderzoek heb ik een compiler-generator gemaakt. Een compiler-generator is een computerprogramma dat, na invoer van een minutieuze beschrijving van een hogere programmeertaal en de gewenste machinetaal, een compiler voor die programmeertaal genereert. De voordelen van een compiler-generator zijn legio. Elke verbetering aan de generator heeft tot gevolg dat elke gegenereerde compiler verbetert. Bovendien worden de produktiekosten en de produktietijd verbonden aan het maken van een compiler, aanzienlijk verminderd. Immers, in plaats van een compiler voor een hogere programmeertaal hoeft alleen nog maar een beschrijving van die hogere programmeertaal geschreven te worden. Een student informatica kan in een paar maanden tijd een compiler genereren, terwijl een groep beroeps programmeurs daar eerder vele maanden tot jaren mee bezig is. Incrementele berekeningen De kracht van de compilers gegenereert door dedoor mij ontwikkelde generator is voornamelijk gelegen in het feit dat ze incrementeel zijn. Dat betekent dat na een kleine verandering in het bronprogramma, de compiler de corresponderende veran- deringen in het doelprogramma aanbrengt|dit in tegenstelling tot het simpelweg vertalen van het gehele (gewijzigde) bronprogramma. Dit laatste zou veel meer tijd zou kosten. Wat een incrementele berekening is wordt elegant ge?llustreerd aan de hand van een compiler-verwante toepassing: een rekenblad of spreadsheet. Een rekenblad bestaat uit cellen in een rechthoekig patroon, zie Figuur 2a. Elke cel wordt aangeduid met een letter-cijfer combinatie. Zo wordt de cel links-boven aangeduid met a1. Een cel kan tekst, getallen of formules bevatten: cel a1 bevat de tekst `item', cel b2 bevat het getal 10 en cel b4 bevat de formule b2 b3. Een rekenblad-evaluator berekent de waarde van de cellen waar formules in staan. Dus, na invoer van het rekenblad in Figuur 2a wordt de uitvoer van Figuur 2b geproduceerd. Stel dat we een verandering aanbrengen in het rekenblad; we voeren een zogeheten edit-operatie uit. We verlagen het getal in cel b2 van 10 naar 9, zie?Informele inleiding 193 boter melk 30 2,50 1,25 item aantal prijs a b c d 1 23 4 b2 b3 x c2 c3 x b4+c4 b2+c2 9 boter melk 30 2,50 1,25 52,50 item aantal prijs a b c d 1 23 4 9 22,50 75,00 39 a. Wijziging in de invoer b. Zuinige herberekening Figuur 3. Wijziging aan een rekenblad Figuur 3a. De rekenblad-evaluator zou alle cellen met formules opnieuw kunnen uitrekenen. Een incrementele evaluator berekent alleen de grijze cellen in Figuur 3b. In dit geval spaart dat de berekening van cel c4 uit. Het is overigens niet eenvoudig om in te zien welke cellen herberekend moeten worden. Om dat te bepalen stelt de rekenblad-evaluator een zogeheten graaf op die de cel-afhankelijkheden weergeeft. Een knoop in de graaf representeert een cel. Er loopt een pijl van knoop b2 naar knoopb4 omdat de formule van cel b4 refereert aan cel b2. Zo'n pijl impliceert dat cel b4 na celb2 uitgerekend moet worden. Bij een incrementele evaluatie moet elke cel wiens knoop in de graaf een opvolger is van b2, herberekend worden, tenzij veranderingen eerder uitdoven. Als voorbeeld van dat laatste, beschouwen we de volgende verandering: de prijs van boter gaat naar 0,25 en de hoeveelheid boter naar 100. In dat geval blijft de waarde van cel b4 25,00 zodat d4 niet herberekend hoeft te worden. Grafen spelen b3 b2 c2 c3 c4 d2 b4 d4 bij incrementele berekeningen een belangrijke rol. Ze komen dan ook veelvuldig in dit proefschrift voor. Compilers worden ook vaak toegepast op slechts weinig veranderde invoer. Hoe vaak wordt een computerprogramma niet gecompileerd om er vervolgens achter te komen dat er een kleine fout in staat? Het is daarom jammer dat er nog zo weinig i:=1 had natuurlijk i:=0 moeten zijn. incrementele compilers zijn. Taal-specieke editors Een editor is een computerprogramma waarmee gegevens in een computer in- gevoerd kunnen worden. Bovendien kunnen met een editor bestaande gegevens gewijzigd worden. Meestal verstaat men onder een editor een algemeen programma waarmee gegevens voor uiteenlopende applicaties (toepassings programma's zoals compilers, rekenbladen, tekstverwerkers) ingevoerd kunnen worden. Een applicatie-specieke editor is een invoer-en-wijzig programma dat \kennis" heeft van een applicatie. Alle huis-tuin-en-keuken applicaties zoals tekstverwerkers L a T E X is geen huis-tuin- en-keuken applicatie. en rekenbladen zijn uitgerust met applicatie-specieke editors. Het grootste voor- deel van zulke editors is dat ze de gebruiker kunnen sturen: er kan geen al te grote onzin in worden gevoerd.?194 Samenvatting Compilers zouden ook uitgerust kunnen worden met een brontaal-specieke editor. Dat is met name interessant als er een incrementele compiler beschikbaar is die tijdens het intypen van het bronprogramma voortdurend het bijbehorende doelprogramma berekend. Zulke systemen zouden de arbeidsproduktiviteit van programmeurs enorm verhogen. Immers, fouten in het bronprogramma worden direct als zodanig herkend door het system, en meegedeeld aan de gebruiker. Het grootste voordeel is echter dat de editor \ondervraagd" kan worden over bepaalde kenmerken van het bronprogramma. Voor ingewijden: als de editor constateert dat i:=1 incorrect is omdat i niet gedeclareerd is kan het een menu aanbieden met alle integer variabelen in de huidige scoop en een optie om de declaratie i:integer toe te voegen aan de declaraties. Kort overzicht Dit proefschrift beschrijft de generatie van incrementele compilers, met name als onderdeel van een taal-specieke \language based" editor. Omdat we uitgaan van een taal-specieke editor, kunnen we het ontleed- traject (lexical scanning en parsing ) overslaan: de editor onderhoudt een boom- representatie van het ingevoerde programma. Dat betekent dat compileren niets De titel: Generating incremental attribute evaluators. anders is dan het attribueren van de boom; de compiler is een (incrementele) attribute evaluator. Het formalisme waarmee we bomen en attributen beschrijven is het attribuut grammatica formalisme. We geven twee methodes om incrementele attribuut evaluatoren te construeren. De eerste methode is een bestaande: visit-sequences sturen boom decoratie. De tweede methode is nieuw: visit-sequences worden afgebeeld op visit-functies die gecached worden om incrementeel gedrag te verkrijgen. Een complicatie bij deze aanpak vormen zogeheten intra-visit-dependencies. Om dat probleem op te lossen worden bindingen ge?ntroduceerd. Visit-functies zijn functies zonder zij-eecten. Dit opent de mogelijkheid tot allerhanden optimalizaties. Aan de orde komen splitting, elimination, unication, folding, normalization en untyping. We bespreken hoe visit-sequences berekend worden aan de hand van een gram- matica. We wijzigen Kastens' ordered scheduling op twee vlakken. Om te beginnen voeren we dat grafen in (in stap 4) waardoor een grotere klasse van gramatica's geaccepteerd wordt. Ten tweede voeren we een nieuw orderings algorithme in (chained scheduling ) dat visit-sequences berekent die beter geschikt zijn voor omzetting naar visit-functies. Een groot deel van het onderzoek heeft zich toegespitst op de haalbaarheid van een functionele aanpak: we hebben een generator geschreven. De gegenereerde evaluatoren zijn eenvoudig, elegant en robuust. Bovenal zijn ze snel. De generator is onder andere gebruikt om een deel van zichzelf te genereren

Contributions to the Construction of Extensible Semantic Editors

This dissertation addresses the need for easier construction and extension of language tools. Specifically, the construction and extension of so-called semantic editors is considered, that is, editors providing semantic services for code comprehension and manipulation. Editors like these are typically found in state-of-the-art development environments, where they have been developed by hand. The list of programming languages available today is extensive and, with the lively creation of new programming languages and the evolution of old languages, it keeps growing. Many of these languages would benefit from proper tool support. Unfortunately, the development of a semantic editor can be a time-consuming and error-prone endeavor, and too large an effort for most language communities. Given the complex nature of programming, and the huge benefits of good tool support, this lack of tools is problematic. In this dissertation, an attempt is made at narrowing the gap between generative solutions and how state-of-the-art editors are constructed today. A generative alternative for construction of textual semantic editors is explored with focus on how to specify extensible semantic editor services. Specifically, this dissertation shows how semantic services can be specified using a semantic formalism called refer- ence attribute grammars (RAGs), and how these services can be made responsive enough for editing, and be provided also when the text in an editor is erroneous. Results presented in this dissertation have been found useful, both in industry and in academia, suggesting that the explored approach may help to reduce the effort of editor construction

Text Mining Infrastructure in R

During the last decade text mining has become a widely used discipline utilizing statistical and machine learning methods. We present the tm package which provides a framework for text mining applications within R. We give a survey on text mining facilities in R and explain how typical application tasks can be carried out using our framework. We present techniques for count-based analysis methods, text clustering, text classification and string kernels.

fUML Activity Diagrams with RAG-controlled Rewriting -A RACR Solution of The TTC 2015 Model Execution Case

This paper summarises a RACR solution of The TTC 2015 Model Execution Case. RACR is a metacompiler library for Scheme. Its most distinguished feature is the seamless combination of reference attribute grammars and graph rewriting combined with incremental evaluation semantics. The presented solution sketches how these integrated analyses and rewriting facilities are used to transform fUML Activity Diagrams to executable Petri nets. Of particular interest are (1) the exploitation of reference attribute grammar analyses for Petri net generation and (2) the efficient execution of generated nets based on the incremental evaluation semantics of RACR

Physical database design in document stores

Tesi en modalitat de cotutela, Universitat Politècnica de Catalunya i Université libre de BruxellesNoSQL is an umbrella term used to classify alternate storage systems to the traditional Relational Database Management Systems (RDBMSs). Among these, Document stores have gained popularity mainly due to the semi-structured data storage model and the rich query capabilities. They encourage users to use a data-first approach as opposed to a design-first one. Database design on document stores is mainly carried out in a trial-and-error or ad-hoc rule-based manner instead of a formal process such as normalization in an RDBMS. However, these approaches could easily lead to a non-optimal design resulting additional costs in the long run. This PhD thesis aims to provide a novel multi-criteria-based approach to database design in document stores. Most of such existing approaches are based on optimizing query performance. However, other factors include storage requirement and complexity of the stored documents specific to each use case. There is a large solution space of alternative designs due to the different combinations of referencing and nesting of data. Thus, we believe multi-criteria optimization is ideal to solve this problem. To achieve this, we need to address several issues that will enable us to apply multi-criteria optimization for the data design problem. First, we evaluate the impact of alternate storage representations of semi-structured data. There are multiple and equivalent ways to physically represent semi-structured data, but there is a lack of evidence about the potential impact on space and query performance. Thus, we embark on the task of quantifying that precisely for document stores. We empirically compare multiple ways of representing semi-structured data, allowing us to derive a set of guidelines for efficient physical database design considering both JSON and relational options in the same palette. Then, we need a formal canonical model that can represent alternative designs. We propose a hypergraph-based approach for representing heterogeneous datastore designs. We extend and formalize an existing common programming interface to NoSQL systems as hypergraphs. We define design constraints and query transformation rules for representative data store types. Next, we propose a simple query rewriting algorithm and provide a prototype implementation together with storage statistics estimator. Next, we require a formal query cost model to estimate and evaluate query performance on alternative document store designs. Document stores use primitive approaches to query processing, such as relying on the end-user to specify the usage of indexes instead of a formal cost model. But we require a reliable approach to compare alternative designs on how they perform on a specific query. For this, we define a generic storage and query cost model based on disk access and memory allocation. As all document stores carry out data operations in memory, we first estimate the memory usage by considering the characteristics of the stored documents, their access patterns, and memory management algorithms. Then, using this estimation and metadata storage size, we introduce a cost model for random access queries. We validate our work on two well-known document store implementations. The results show that the memory usage estimates have an average precision of 91% and predicted costs are highly correlated to the actual execution times. During this work, we also managed to suggest several improvements to document stores. Finally, we implement the automated database design solution using multi-criteria optimization. We introduce an algebra of transformations that can systematically modify a design of our canonical representation. Then, using them, we implement a local search algorithm driven by a loss function that can propose near-optimal designs with high probability. We compare our prototype against an existing document store data design solution. Our proposed designs have better performance and are more compact with less redundancy.NoSQL descriu sistemes d'emmagatzematge alternatius als tradicionals de gestió de bases de dades relacionals (RDBMS). Entre aquests, els magatzems de documents han guanyat popularitat principalment a causa del model de dades semiestructurat i les riques capacitats de consulta. Animen els usuaris a utilitzar un enfocament de dades primer, en lloc d'un enfocament de disseny primer. El disseny de dades en magatzems de documents es porta a terme principalment en forma d'assaig-error o basat en regles ad-hoc en lloc d'un procés formal i sistemàtic com ara la normalització en un RDBMS. Aquest enfocament condueix fàcilment a un disseny no òptim que generarà costos addicionals a llarg termini. La majoria dels enfocaments existents es basen en l'optimització del rendiment de les consultes. Aquesta tesi pretén, en canvi, proporcionar un nou enfocament basat en diversos criteris per al disseny de bases de dades en magatzems de documents, inclouen el requisit d'espai i la complexitat dels documents emmagatzemats específics per a cada cas d'ús. En general, hi ha un gran espai de solucions de dissenys alternatives. Per tant, creiem que l'optimització multicriteri és ideal per resoldre aquest problema. Per aconseguir-ho, hem d'abordar diversos problemes que ens permetran aplicar l'optimització multicriteri. En primer, avaluem l'impacte de les representacions alternatives de dades semiestructurades. Hi ha maneres múltiples i equivalents de representar dades semiestructurades, però hi ha una manca d'evidència sobre l'impacte potencial en l'espai i el rendiment de les consultes. Així, ens embarquem en la tasca de quantificar-ho. Comparem empíricament múltiples representacions de dades semiestructurades, cosa que ens permet derivar directrius per a un disseny eficient tenint en compte les opcions dels JSON i relacionals alhora. Aleshores, necessitem un model canònic que pugui representar dissenys alternatius i proposem un enfocament basat en hipergrafs. Estenem i formalitzem una interfície de programació comuna existent als sistemes NoSQL com a hipergrafs. Definim restriccions de disseny i regles de transformació de consultes per a tipus de magatzem de dades representatius. A continuació, proposem un algorisme de reescriptura de consultes senzill i proporcionem una implementació juntament amb un estimador d'estadístiques d'emmagatzematge. Els magatzems de documents utilitzen enfocaments primitius per al processament de consultes, com ara confiar en l'usuari final per especificar l'ús d'índexs en lloc d'un model de cost. Conseqüentment, necessitem un model de cost de consulta per estimar i avaluar el rendiment en dissenys alternatius. Per això, definim un model genèric propi basat en l'accés a disc i l'assignació de memòria. Com que tots els magatzems de documents duen a terme operacions de dades a memòria, primer estimem l'ús de la memòria tenint en compte les característiques dels documents emmagatzemats, els seus patrons d'accés i els algorismes de gestió de memòria. A continuació, utilitzant aquesta estimació i la mida d'emmagatzematge de metadades, introduïm un model de costos per a consultes d'accés aleatori. Validem el nostre treball en dues implementacions conegudes. Els resultats mostren que les estimacions d'ús de memòria tenen una precisió mitjana del 91% i els costos previstos estan altament correlacionats amb els temps d'execució reals. Finalment, implementem la solució de disseny automatitzat de bases de dades mitjançant l'optimització multicriteri. Introduïm una àlgebra de transformacions que pot modificar sistemàticament un disseny en la nostra representació canònica. A continuació, utilitzant-la, implementem un algorisme de cerca local impulsat per una funció de pèrdua que pot proposar dissenys gairebé òptims amb alta probabilitat. Comparem el nostre prototip amb una solució de disseny de dades de magatzem de documents existent. Els nostres dissenys proposats tenen un millor rendiment i són més compactes, amb menys redundànciaNoSQL est un terme générique utilisé pour classer les systèmes de stockage alternatifs aux systèmes de gestion de bases de données relationnelles (SGBDR) traditionnels. Au moment de la rédaction de cet article, il existe plus de 200 systèmes NoSQL disponibles qui peuvent être classés en quatre catégories principales sur le modèle de stockage de données : magasins de valeurs-clés, magasins de documents, magasins de familles de colonnes et magasins de graphiques. Les magasins de documents ont gagné en popularité principalement en raison du modèle de stockage de données semi-structuré et des capacités de requêtes riches par rapport aux autres systèmes NoSQL, ce qui en fait un candidat idéal pour le prototypage rapide. Les magasins de documents encouragent les utilisateurs à utiliser une approche axée sur les données plutôt que sur la conception. La conception de bases de données sur les magasins de documents est principalement effectuée par essais et erreurs ou selon des règles ad hoc plutôt que par un processus formel tel que la normalisation dans un SGBDR. Cependant, ces approches pourraient facilement conduire à une conception de base de données non optimale entraînant des coûts supplémentaires de traitement des requêtes, de stockage des données et de refonte. Cette thèse de doctorat vise à fournir une nouvelle approche multicritère de la conception de bases de données dans les magasins de documents. La plupart des approches existantes de conception de bases de données sont basées sur l’optimisation des performances des requêtes. Cependant, d’autres facteurs incluent les exigences de stockage et la complexité des documents stockés spécifique à chaque cas d’utilisation. De plus, il existe un grand espace de solution de conceptions alternatives en raison des différentes combinaisons de référencement et d’imbrication des données. Par conséquent, nous pensons que l’optimisation multicritères est idéale par l’intermédiaire d’une expérience éprouvée dans la résolution de tels problèmes dans divers domaines. Cependant, pour y parvenir, nous devons résoudre plusieurs problèmes qui nous permettront d’appliquer une optimisation multicritère pour le problème de conception de données. Premièrement, nous évaluons l’impact des représentations alternatives de stockage des données semi-structurées. Il existe plusieurs manières équivalentes de représenter physiquement des données semi-structurées, mais il y a un manque de preuves concernant l’impact potentiel sur l’espace et sur les performances des requêtes. Ainsi, nous nous lançons dans la tâche de quantifier cela précisément pour les magasins de documents. Nous comparons empiriquement plusieurs façons de représenter des données semi-structurées, ce qui nous permet de dériver un ensemble de directives pour une conception de base de données physique efficace en tenant compte à la fois des options JSON et relationnelles dans la même palette. Ensuite, nous avons besoin d’un modèle canonique formel capable de représenter des conceptions alternatives. Dans cette mesure, nous proposons une approche basée sur des hypergraphes pour représenter des conceptions de magasins de données hétérogènes. Prenant une interface de programmation commune existante aux systèmes NoSQL, nous l’étendons et la formalisons sous forme d’hypergraphes. Ensuite, nous définissons les contraintes de conception et les règles de transformation des requêtes pour trois types de magasins de données représentatifs. Ensuite, nous proposons un algorithme de réécriture de requête simple à partir d’un algorithme générique dans un magasin de données sous-jacent spécifique et fournissons une implémentation prototype. De plus, nous introduisons un estimateur de statistiques de stockage sur les magasins de données sous-jacents. Enfin, nous montrons la faisabilité de notre approche sur un cas d’utilisation d’un système polyglotte existant ainsi que son utilité dans les calculs de métadonnées et de chemins de requêtes physiques. Ensuite, nous avons besoin d’un modèle de coûts de requêtes formel pour estimer et évaluer les performances des requêtes sur des conceptions alternatives de magasin de documents. Les magasins de documents utilisent des approches primitives du traitement des requêtes, telles que l’évaluation de tous les plans de requête possibles pour trouver le plan gagnant et son utilisation dans les requêtes similaires ultérieures, ou l’appui sur l’usager final pour spécifier l’utilisation des index au lieu d’un modèle de coûts formel. Cependant, nous avons besoin d’une approche fiable pour comparer deux conceptions alternatives sur la façon dont elles fonctionnent sur une requête spécifique. Pour cela, nous définissons un modèle de coûts de stockage et de requête générique basé sur l’accès au disque et l’allocation de mémoire qui permet d’estimer l’impact des décisions de conception. Étant donné que tous les magasins de documents effectuent des opérations sur les données en mémoire, nous estimons d’abord l’utilisation de la mémoire en considérant les caractéristiques des documents stockés, leurs modèles d’accès et les algorithmes de gestion de la mémoire. Ensuite, en utilisant cette estimation et la taille de stockage des métadonnées, nous introduisons un modèle de coûts pour les requêtes à accès aléatoire. Il s’agit de la première tenta ive d’une telle approche au meilleur de notre connaissance. Enfin, nous validons notre travail sur deux implémentations de magasin de documents bien connues : MongoDB et Couchbase. Les résultats démontrent que les estimations d’utilisation de la mémoire ont une précision moyenne de 91% et que les coûts prévus sont fortement corrélés aux temps d’exécution réels. Au cours de ce travail, nous avons réussi à proposer plusieurs améliorations aux systèmes de stockage de documents. Ainsi, ce modèle de coûts contribue également à identifier les discordances entre les implémentations de stockage de documents et leurs attentes théoriques. Enfin, nous implémentons la solution de conception automatisée de bases de données en utilisant l’optimisation multicritères. Tout d’abord, nous introduisons une algèbre de transformations qui peut systématiquement modifier une conception de notre représentation canonique. Ensuite, en utilisant ces transformations, nous implémentons un algorithme de recherche locale piloté par une fonction de perte qui peut proposer des conceptions quasi optimales avec une probabilité élevée. Enfin, nous comparons notre prototype à une solution de conception de données de magasin de documents existante uniquement basée sur le coût des requêtes. Nos conceptions proposées ont de meilleures performances et sont plus compactes avec moins de redondancePostprint (published version