@article{Chauvel09a,
	Abstract = {Many Embedded Systems are supposed to run continuously, which includes
	recovering from errors by adapting their configuration or their architecture
	to changing conditions in their environment. The design of such systems
	has to relate some high-level extra-functional properties to some
	low level ones such as memory or CPU consumption by defining some
	complex feed-back loops for the dynamic adaptation of the system.
	However, although feed-back loops (also known as ``adaptation policies'')
	are a well-known idea, the design phase does not deal with those
	feed-back loops and thus the needed sensors and actuators are hard-coded
	during the development phase. This leads to expensive roll-back operations
	in the design process. To avoid that, we suggest a model-driven process
	based on new executable meta-modelling techniques. At modelling time,
	designers have to complement the architectural description with some
	sensors and actuators related to the involved extra-functional properties.
	It allows designers to specify in a consistent way the related adaptation
	policies. Then, since the models are executable, some simulations
	of the adaptation policies can be performed at design time to evaluate
	their performances with respect to some relevant test scenarios.},
	Author = {Chauvel, Franck and Barais, Olivier and Borne, Isabelle and J{\'e}z{\'e}quel, Jean-Marc},
	Journal = {Revue de l'Electricit{\'e} et de l'Electronique (REE)},
	Month = feb,
	Number = {2},
	Pages = {38--44},
	Publisher = {SEE},
	Title = {Un processus {\`a} base de mod{\`e}les pour les syst{\`e}mes auto-adaptatifs},
	Url = {http://www.irisa.fr/triskell/publis/2009/Chauvel09a.pdf},
	X-Editorial-Board = {yes},
	X-International-Audience = {no},
	X-Language = {FR},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Chauvel09a.pdf}}

@inproceedings{Chauvel09b,
	Abstract = {Ever-growing systems' complexity and novel requirements engineering
	approaches such as reuse or globalization imply that requirements
	are produced by different stakeholders and written in possibly different
	languages. In this context, checking consistency so that requirements
	specifications are amenable to formal analysis is a challenge. Current
	techniques either fail to consider the requirement set as a whole,
	missing certain inconsistency types or are unable to take heterogeneous
	(i.e. expressed in different languages) specifications into account.
	We propose to use model composition to address this problem in a
	staged approach. First, heterogeneous requirements are translated
	in model fragments instances of a common metamodel. Then, fragments
	are merged in one unique model. On such a model inconsistencies such
	as under-specifications can be incrementally detected and formal
	analysis is made possible. Our approach is fully supported by our
	model composition framework. We propose model composition as means
	to address flexibility needs in requirements integration. Threats
	to validity such as the impact of new requirements languages needs
	to be addressed in future work.},
	Address = {Toulouse, France},
	Author = {Chauvel, Franck and Barais, Olivier and Plouzeau, No{\"e}l and Borne, Isabelle and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {Actes des Journ{\'e}es nationales du GDR GPL 2009},
	Comment = {Workshop,fr},
	Month = jan,
	Title = {Composition et expression qualitative de politiques d'adaptation pour les composants Fractal},
	Url = {http://www.irisa.fr/triskell/publis/2009/Chauvel09b.pdf},
	X-Country = {FR},
	X-International-Audience = {no},
	X-Language = {FR},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Chauvel09b.pdf}}

@article{Combemale09a,
	Abstract = {In the context of MDE (Model-Driven Engineering), our objective is
	to define the semantics for a given DSL (Domain Specific Language)
	either to simulate its models or to check properties on them using
	model-checking techniques. In both cases, the purpose is to formalize
	the DSL semantics as it is known by the DSL designer but often in
	an informal way. After several experiments to define operational
	semantics on the one hand, and translational semantics on the other
	hand, we discuss both approaches and we specify in which cases these
	semantics seem to be judicious. As a second step, we introduce a
	pragmatic and instrumented approach to define a translational semantics
	and to validate it against a reference operational semantics expressed
	by the DSL designer. We apply this approach to the xSPEM process
	description language in order to verify process models. },
	Author = {Combemale, Benoit and Cr{\'e}gut, Xavier and Garoche, Pierre-Loïc and Thirioux, Xavier},
	Journal = {Journal of Software},
	Month = {december},
	Number = {6},
	Optpages = {to be published},
	Publisher = {Academy Publisher},
	Title = {Essay on Semantics Definition in MDE. An Instrumented Approach for Model Verification},
	Url = {http://www.academypublisher.com/ojs/index.php/jsw/article/view/0409943958},
	Volume = {4},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	Year = {2009},
	Bdsk-Url-1 = {http://www.academypublisher.com/ojs/index.php/jsw/article/view/0409943958}}

@inproceedings{Daubert09a,
	Abstract = {{L}'industrie se tourne de plus en plus vers les architectures orient{\'e}es services ({S}ervice {O}riented {A}rchitectures, {SOA}) afin de construire des applications par composition de services existants et en cours de fonctionnement. {L}a profusion des services et leur utilisation en environnement distribu{\'e} dans un contexte de plus en plus dynamique engendre des besoins d'auto-adaptation qui n'ont pas encore {\'e}t{\'e}s couvert par la communaut{\'e} scientifique. {C}et article pr{\'e}sente un syst{\`e}me d'adaptation g{\'e}n{\'e}rique pour les services et attaque la probl{\'e}matique de la migration de service, appliqu{\'e} {\`a} l'architecture {OSG}i.},
	Address = {{T}oulouse {F}rance},
	Affiliation = {{PARIS} - {INRIA} - {IRISA} - {CNRS} : {UMR}6074 - {INRIA} - {\'e}cole normale sup{\'e}rieure de {C}achan - {ENS} {C}achan - {I}nstitut {N}ational des {S}ciences {A}ppliqu{\'e}es de {R}ennes - {U}niversit{\'e} de {R}ennes 1 - {TRISKELL} - {INRIA} - {IRISA} - {CNRS} : {UMR}6074 - {INRIA} - {I}nstitut {N}ational des {S}ciences {A}ppliqu{\'e}es de {R}ennes - {U}niversit{\'e} de {R}ennes 1},
	Audience = {nationale},
	Author = {Daubert, Erwan and Gauvrit, Guillaume and Andr{\'e}, Fran{\c{c}}oise and Barais, Olivier},
	Booktitle = {{R}en{P}ar'19},
	Day = {08},
	Keywords = {auto-adaptation;services;distribution;migration;{OSG}i},
	Language = {{F}ran{\c{c}}ais},
	Month = {09},
	Title = {{A}daptation de services en environnement distribu{\'e}},
	Url = {http://hal.inria.fr/inria-00411514/PDF/Daubert_Gauvrit_poster_renpar2009.pdf},
	Year = {2009},
	Bdsk-Url-1 = {http://hal.inria.fr/inria-00411514/PDF/Daubert_Gauvrit_poster_renpar2009.pdf}}

@inproceedings{Delamare09a,
	Abstract = {Aspect-oriented programming (AOP) languages introduce new constructs
	that can lead to new types of faults, which must be targeted by testing
	techniques. In particular, AOP languages such as AspectJ use a pointcut
	descriptor (PCD) that provides a convenient way to declaratively
	specify a set of joinpoints in the program where the aspect should
	be woven. However, a major difficulty when testing that the PCD matches
	the intended set of joinpoints is the lack of precise specification
	for this set other than the PCD itself. 
	
	 In this paper, we propose a test-driven approach for the development
	and validation of the PCD. We developed a tool, AdviceTracer, which
	enriches the JUnit API with new types of assertions that can be used
	to specify the expected joinpoints. In order to validate our approach,
	we also developed a mutation tool that systematically injects faults
	into PCDs. Using these two tools, we perform experiments to validate
	that our approach can be applied for specifying expected joinpoints
	and for detecting faults in the PCD.},
	Address = {Denver, Colorado, USA},
	Author = {Delamare, Romain and Baudry, Benoit and Ghosh, Sudipto and Le Traon, Yves},
	Booktitle = {ICST '09: Proceedings of the 2$^{nd}$ International Conference on Software Testing, Verification, and Validation},
	Month = {April},
	Title = {A Test-Driven Approach to Developing Pointcut Descriptors in AspectJ},
	Url = {http://www.irisa.fr/triskell/publis/2009/Delamare09a.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Delamare09a.pdf}}

@inproceedings{Delamare09b,
	Abstract = {Aspect-oriented programming introduces new challenges for software
	testing. In particular the pointcut descriptor (PCD) requires particular
	attention from testers. The PCD describes the set of joinpoints where
	the advices are woven. In this paper we present a tool, AjMutator,
	for the mutation analysis of PCDs. AjMutator implements several mutation
	operators that introduce faults in the PCDs to generate a set of
	mutants. AjMutator classifies the mutants according to the set of
	joinpoints they match compared to the set of joinpoints matched by
	the initial PCD. An interesting result is that this automatic classification
	can identify equivalent mutants for a particular class of PCDs. AjMutator
	can also run a set of test cases on the mutants to give a mutation
	score. We have applied AjMutator on two systems to show that this
	tool is suitable for the mutation analysis of PCDs on large AspectJ
	systems.},
	Address = {Denver, Colorado, USA},
	Author = {Delamare, Romain and Baudry, Benoit and Le Traon, Yves},
	Booktitle = {Mutation'09: Proceedings of the 4th International Workshop on Mutation Analysis},
	Month = {April},
	Title = {AjMutator: A Tool For The Mutation Analysis Of AspectJ Pointcut Descriptors},
	Url = {http://www.irisa.fr/triskell/publis/2009/Delamare09b.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Delamare09b.pdf}}

@phdthesis{Delamare09c,
	Abstract = { La programmation orient{\'e}e aspects s{\'e}pare les diff{\'e}rentes pr{\'e}occupations
	pour am{\'e}liorer la modularit{\'e}. Ce paradigme introduit de nouveaux
	d{\'e}fis pour le test. Afin de proposer des solutions efficaces {\`a} ces
	probl{\`e}mes, nous avons {\'e}tudi{\'e} l'utilisation d'AspectJ dans 38 projets
	libres. Ces observations ont r{\'e}v{\'e}l{\'e} que les aspects sont peu utilis{\'e},
	et avec pr{\'e}caution, et que la programmation orient{\'e}e aspect diminue
	la testabilit{\'e} en augmentant le couplage. Nous avons d{\'e}velopp{\'e} une
	analyse statique de l'impact des aspects sur les cas de test. Le
	but est de d{\'e}terminer statiquement quels sont les cas de test qui
	sont impact{\'e}s par l'introduction d'un aspect et qui doivent {\^e}tre
	modifi{\'e}s pour prendre en compte les changements. Cette analyse outill{\'e}e,
	vise {\`a} limiter le temps d'ex{\'e}cution des cas de test et permet au
	testeur de se concentrer sur les cas de test qui doivent {\^e}tre modifi{\'e}s.
	Nous proposons une approche, impl{\'e}ment{\'e}e dans un outil nomm{\'e} AdviceTracer,
	pour tester les expressions de point de coupe s{\'e}par{\'e}ment des greffons.
	Cet outil permet la d{\'e}finition d'un oracle sp{\'e}cifiquement adapt{\'e}
	{\`a} la d{\'e}tection d'erreurs dans un point de coupe. Ceci permet {\`a} l'oracle
	de tester si un greffon a {\'e}t{\'e} correctement tiss{\'e}, sans d{\'e}pendre du
	comportement du greffon. Dans le cadre de cette th{\`e}se nous avons
	eu besoin de diff{\'e}rents outils d'analyse. AjMetrics est un outil
	qui mesure diverses m{\'e}triques sur les programmes orient{\'e}s aspect
	en utilisant un formalisme. AjMutator est un outil d'analyse de mutations
	de programmes orient{\'e}s aspect, qui est capable d'ins{\'e}rer des erreurs
	dans les expressions de point de coupe. },
	Author = {Delamare, Romain},
	Month = {December},
	School = {Universit{\'e} de Rennes 1},
	Title = {Analyses Automatiques pour le Test de Programmes Orient{\'e}s Aspect},
	Url = {http://www.irisa.fr/triskell/publis/2009/Delamare09c.pdf},
	X-Country = {FR},
	X-Editorial-Board = {no},
	X-International-Audience = {no},
	X-Language = {FR},
	X-Proceedings = {no},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Delamare09c.pdf}}

@inproceedings{dhaussy09,
	Abstract = {Formal methods need better integration with engineering practices.
	In the context of embedded systems, model checking requires first
	to model the component to be verified, then to formalize the properties
	to be satisfied and finally to describe the behavior of the environment.
	The proof context, which is a model of the environment behavior,
	is in practice often neglected. It is, however, of great importance
	in order to reduce the complexity of the proof. The question is to
	formalize such a proof context. We are experimenting a DSL, named
	Context Description Language (CDL), which describes a software component
	environment using actors and sequence diagrams, together with the
	properties to be checked. The properties are specified with patterns,
	formulated textually and attached to specific regions of the context.
	CDL models are translated into timed automata which feed model checkers.
	Properties of the model are, as a result, checked automatically.
	The contribution of the paper is a report on the experiments applied
	on several industrial embedded system applications provided by the
	aviation, space and military areas.},
	Address = {Denver, Colorado, USA},
	Author = {Dhaussy, Philippe and Pillain, Pierre-Yves and Creff, Stephen and Raji, Amine and Le Traon, Yves and Baudry, Benoit},
	Booktitle = {ACM/IEEE 12th International Conference on Model Driven Engineering Languages and Systems (MODELS'09)},
	Month = {October},
	Pages = {438-452},
	Title = {Evaluating Context Descriptions and Property Definition Patterns for Software Formal Validation},
	Url = {http://www.irisa.fr/triskell/publis/2009/dhaussy09.pdf},
	X-Country = {US},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/dhaussy09.pdf}}

@article{France09a,
	Abstract = {From a modeling point of view, the terms aspect and model can be considered
	synonymous. This notion of aspect goes beyond the usual meaning found
	in the Aspect Oriented Programming community where an aspect is often
	narrowly dened as the modularization of a cross-cutting concern.
	From this perspective, work on aspect-oriented approaches to modeling
	is important because it can yield signicant insights into how the
	MDE vision of software development can be realized. There is thus
	a growing community interested in the convergence of Aspect-Oriented
	Software Development (AOSD) and MDE ideas. In this issue, we present
	papers that provide good examples of how AOSD and MDE ideas can be
	integrated to produce techniques that manage software complexity.},
	Author = {France, Robert and J{\'e}z{\'e}quel, Jean-Marc},
	Comment = {en},
	Eid = {Springer-Verlag},
	Journal = {Transactions on Aspect-Oriented Software Development (TAOSD)},
	Pages = {16-21},
	Publisher = {Springer},
	Title = {Editorial for the Special Issue on Aspects and Model-Driven Engineering},
	Url = {http://www.irisa.fr/triskell/publis/2009/France09a.pdf},
	Volume = {LNCS 5560},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/France09a.pdf}}

@inproceedings{Istoan09a,
	Abstract = {Ageing populations and the necessity to reduce environmental impact
	raise new challenges on our living buildings. Convergence of home
	control systems (air conditioning, light management) and computer
	science, or house automation, allows to enhance comfort, security
	and health of inhabitants, and reduce energy consumption. Each of
	these abilities can be perceived as a service provided by the house
	automation system. Starting from this point, we developed ENTIMID
	, a middleware able to make systems from different brands cooperate
	in a single service-based platform. Yet the proliferation and variability
	of such services, and needs to tailor each system to a particular
	building, make the design of these systems complex. In this prospective
	paper, we explain how the notion of dynamic software product line
	facilitates such designs by providing sophisticated techniques for
	managing variability across services from design time to runtime
	and allowing their automatic composition.},
	Address = {Xiamen, CHINA},
	Author = {Istoan, Paul and Nain, Gr{\'e}gory and Perrouin, Gilles and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {9th IEEE International Conference on Computer and Information Technology},
	Comment = {en},
	Date-Added = {2009-07-06 16:59:16 +0200},
	Date-Modified = {2009-07-06 17:40:55 +0200},
	Month = oct,
	Title = {Dynamic Software Product Lines for Service-Based Systems},
	Url = {http://www.irisa.fr/triskell/publis/2009/Istoan09a.pdf},
	X-Country = {CN},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Istoan09a.pdf}}

@article{Koudri09a,
	Abstract = {Dans cet article, nous pr{\'e}sentons un flot IDM de conception de SoC
	(System-On-Chip) bas{\'e} sur l'utilisation du profile UML MARTE (Modeling
	and Analysis of Real-Time Embedded Systems), d{\'e}di{\'e} {\`a} la conception
	et l'analyse de syst{\`e}me temps r{\'e}el embarqu{\'e}s et r{\'e}cemment standardis{\'e}
	par l'OMG. Le flot pr{\'e}sent{\'e} adresse les probl{\'e}matiques de la communaut{\'e}
	de l'ESL (Electronic System Level) et s'inscrit dans le cadre du
	projet MoPCoM (http://www.mopcom.fr).},
	Author = {Koudri, Ali and Champeau, Jo{\"e}l and Aulagnier, Denis and Vojtisek, Didier},
	Editor = {{B}azex, {P}ierre and {C}anals, {A}gusti and {M}illan, {T}hierry},
	Journal = {G{\'e}nie Logiciel - Ing{\'e}ni{\'e}rie dirig{\'e}e par les mod{\`e}les},
	Month = {sep},
	Page = {25--30},
	Publisher = {{R}evue {G}{\'e}nie {L}ogiciel - {AFCET}},
	Title = {Processus MOPCOM pour SoC/SoPC},
	Url = {http://www.irisa.fr/triskell/publis/2009/Koudri09a.pdf},
	X-Country = {FR},
	X-Editorial-Board = {no},
	X-International-Audience = {no},
	X-Language = {FR},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Koudri09a.pdf}}

@inproceedings{legloahec09a,
	Abstract = {Les bonnes pratiques sont des techniques et des m{\'e}thodes, capitalis{\'e}es
	par une entreprise ou par une communaut{\'e}, dont l'efficacit{\'e}
	a {\'e}t{\'e} constat{\'e}e lors des projets de d{\'e}veloppement.
	Les bonnes pratiques sont conserv{\'e}es par les entreprises au mieux
	de mani{\`e}re	informelle au d{\'e}tour de guides ou de manuels qualit{\'e},
	au pire elles font partie d'une culture 	
	implicite fortement tributaire de certaines individualit{\'e}s. Dans
	cet article, nous proposons 	
	d'exprimer de mani{\`e}re formelle les bonnes pratiques orient{\'e}es
	processus. Cela offre deux 	
	 avantages : d'une part une conservation de mani{\`e}re non ambigu{\¨e}
	et structur{\'e}e et d'autre part la	
	 possibilit{\'e} d'automatiser le controle de leur respect. Nous {\'e}valuons
	l'int{\'e}ret du langage SPEM pour 	
	 exprimer les bonnes pratiques. Une exp{\'e}rimentation a {\'e}t{\'e}
	men{\'e}e avec un partenaire industriel 
	
	 sp{\'e}cialis{\'e} dans des projets de d{\'e}veloppement Web.},
	Address = {Nancy, France},
	Author = {Le Gloahec, Vincent and Fleurquin, R{\'e}gis and Sadou, Salah},
	Booktitle = {5{\`e}mes Journ{\'e}es de l'Ing{\'e}nierie dirig{\'e}e par les mod{\`e}les (IDM 2009)},
	Month = mar,
	Page = {95--100},
	Title = {Formalisation de bonnes pratiques dans les proc{\'e}d{\'e}s de d{\'e}veloppement logiciels},
	Url = {http://www.irisa.fr/triskell/publis/2009/legloahec09a.pdf},
	X-Country = {FR},
	X-Editorial-Board = {yes},
	X-International-Audience = {no},
	X-Language = {FR},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/legloahec09a.pdf}}

@article{Moha09a,
	Abstract = {Code and design smells are recurring design problems in software systems
	that must be identified to avoid their possible negative consequences
	on development and maintenance. Consequently, several smell detection
	approaches and tools have been proposed in the literature. However,
	so far, they allow the detection of predefined smells but the detection
	of new smells or smells adapted to the context of the analysed systems
	is possible only by implementing new detection algorithms manually.
	Moreover, previous approaches do not explain the transition from
	specifications of smells to their detection. Finally, the validation
	of the existing approaches and tools has been limited on few proprietary
	systems and on a reduced number of smells. In this paper, we introduce
	an approach to automate the generation of detection algorithms from
	specifications written using a domain-specific language. This language
	is defined from a thorough domain analysis. It allows the specification
	of smells using high-level domain-related abstractions. It allows
	the adaptation of the specifications of smells to the context of
	the analysed systems.We specify 10 smells, generate automatically
	their detection algorithms using templates, and validate the algorithms
	in terms of precision and recall on Xerces v2.7.0 and GanttProject
	v1.10.2, two open-source object-oriented systems.We also compare
	the detection results with those of a previous approach, iPlasma.},
	Author = {Moha, Naouel and Gu{\'e}h{\'e}neuc, Yann-Ga{\"e}l and Le Meur, Anne-Fran{\c c}oise and Duchien, Laurence and Tiberghien, Alban},
	Journal = {Formal Aspects of Computing},
	Month = {May},
	Publisher = {Springer},
	Title = {From a Domain Analysis to the Specification and Detection of Code and Design Smells},
	Url = {http://www.irisa.fr/triskell/publis/2009/Moha09a.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Pays = {NO},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Moha09a.pdf}}

@inproceedings{Moha09b,
	Abstract = {``God class'' is a term used to describe a certain type of large classes
	which ``know too much or do too much''. Often a God class (GC) is created
	by accident as functionalities are incrementally added to a central
	class over the course of its evolution. GCs are generally thought
	to be examples of bad code that should be detected and removed to
	ensure software quality. However, in some cases, a GC is created
	by design as the best solution to a particular problem because, for
	example, the problem is not easily decomposable or strong requirements
	on efficiency exist. In this paper, we study in two open-source systems
	the ``life cycle'' of GCs: how they arise, how prevalent they are,
	and whether they remain or they are removed as the systems evolve
	over time, through a number of versions. We show how to detect the
	degree of ``godliness'' of classes automatically. Then, we show that
	by identifying the evolution of ``godliness'', we can distinguish between
	those classes that are so by design (good code) from those that occurred
	by accident (bad code). This methodology can guide software quality
	teams in their efforts to implement prevention and correction mechanisms.},
	Address = {Lille, France},
	Author = {Vaucher, St{\'e}phane and Khomh, Foutse and Moha, Naouel and Gu{\'e}h{\'e}neuc, Yann-Ga{\"e}l},
	Booktitle = {16th Working Conference on Reverse Engineering (WCRE 2009), IEEE Computer Society Press (WCRE'09)},
	Month = {Oct},
	Title = {{Tracking Design Smells: Lessons from a Study of God Classes}},
	Url = {http://www.irisa.fr/triskell/publis/2009/Moha09b.pdf},
	X-Country = {FR},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Pays = {FR},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Moha09b.pdf}}

@inproceedings{Moha09c,
	Abstract = {Many modeling languages share some common concepts and principles.
	For example, Java, MOF, and UML share some aspects of the concepts
	of classes, methods, attributes, and inheritance. However, model
	transformations such as refactorings specified for a given language
	cannot be readily reused for another language because their related
	metamodels may be structurally different. Our aim is to enable a
	flexible reuse of model transformations across various metamodels.
	Thus, in this paper, we present an approach allowing the specification
	of generic model transformations, in particular refactorings, so
	that they can be applied to different metamodels. Our approach relies
	on two mechanisms: (1) an adaptation based mainly on the weaving
	of aspects; (2) the notion of model typing, an extension of object
	typing in the model-oriented context. We validated our approach by
	performing some experiments that consisted of specifying three well
	known refactorings (Encapsulate Field, Move Method, and Pull Up Method)
	and applying each of them onto three different metamodels (Java,
	MOF, and UML).},
	Address = {Denver, Colorado, USA},
	Author = {Moha, Naouel and Mah{\'e}, Vincent and Barais, Olivier and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {ACM/IEEE 12th International Conference on Model Driven Engineering Languages and Systems (MODELS'09)},
	Comment = {use_kermeta, cite_kermeta, en},
	Month = {Oct},
	Title = {{Generic Model Refactorings}},
	Url = {http://www.irisa.fr/triskell/publis/2009/Moha09c.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Pays = {US},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Moha09c.pdf}}

@article{Monperrus09a,
	Abstract = {This article reports on an experiment to apply a model-driven approach
	for systems engineering in an industrial context. This experiment
	consisted of setting up a model-driven simulation environment for
	a maritime surveillance system. The simulation is fully based on
	three models, each conforming to a specic metamodel. We discuss the
	main advances given by model-driven orientated simulation for systems
	engineering.},
	Author = {Monperrus, Martin and Long, Benoit and Champeau, Jo{\"e}l and Hoeltzener, Brigitte and Marchalot, Gabriel and J{\'e}z{\'e}quel, Jean-Marc},
	Journal = {Systems Engineering Journal},
	Optpages = {to be published},
	Url = {http://www.irisa.fr/triskell/publis/2009/Monperrus09a.pdf},
	Publisher = {John Wiley \& Sons},
	Title = {Model-driven Architecture of a Maritime Surveillance System Simulator},
	Volume = {13},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	Year = {2009}}

@inproceedings{Morin09a,
	Abstract = {Since software systems need to be continuously available under varying
	conditions, their ability to evolve at runtime is increasingly seen
	as one key issue. Modern programming frameworks already provide support
	for dynamic adaptations. However the high-variability of features
	in Dynamic Adaptive Systems (DAS) introduces an explosion of possible
	runtime system configurations (often called modes) and mode transitions.
	Designing these configurations and their transitions is tedious and
	error-prone, making the system feature evolution difficult. While
	Aspect-Oriented Modeling (AOM) was introduced to improve the modularity
	of software, this paper presents how an AOM approach can be used
	to tame the combinatorial explosion of DAS modes. Using AOM techniques,
	we derive a wide range of modes by weaving aspects into an explicit
	model reflecting the runtime system. We use these generated modes
	to automatically adapt the system. We validate our approach on a
	schizophrenic middleware for home automation currently deployed in
	Rennes metropolis.},
	Address = {Vancouver, Canada},
	Author = {Morin, Brice and Barais, Olivier and Nain, Gr{\'e}gory and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {31st International Conference on Software Engineering (ICSE'09)},
	Comment = {use_kermeta, cite_kermeta, en},
	Month = {May},
	Title = {{Taming Dynamically Adaptive Systems with Models and Aspects}},
	Url = {http://www.irisa.fr/triskell/publis/2009/Morin09a.pdf},
	X-Country = {CA},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Morin09a.pdf}}

@inproceedings{Morin09b,
	Abstract = {The increasing need for continuously available software systems has
	raised two key-issues: self-adaptation and design evolution. The
	former one requires software systems to monitor their execution platform
	and automatically adapt their configuration and/or architecture to
	adjust their quality of service (optimization, fault-handling). The
	later one requires new design decisions to be reflected on the fly
	on the running system to ensure the needed high availability (new
	requirements, corrective and preventive maintenance). However, design
	evolution and selfadaptation are not independent and reflecting a
	design evolution on a running self-adaptative system is not always
	safe. We propose to unify run-time adaptation and run-time evolution
	by monitoring both the run-time platform and the design models. Thus,
	it becomes possible to correlate those heterogeneous events and to
	use pattern matching on events to elaborate a pertinent decision
	for run-time adaptation. A flood prediction system deployed along
	the Ribble river (Yorkshire, England) is used to illustrate how to
	unify design evolution and run-time adaptation and to safely perform
	runtime evolution on adaptive systems.},
	Address = {Xiamen, China},
	Author = {Morin, Brice and Ledoux, Thomas and Ben Hassine, Mahmoud and Chauvel, Franck and Barais, Olivier and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {IEEE 9th International Conference on Computer and Information Technology (CIT'09)},
	Comment = {en},
	Month = {Oct},
	Title = {{Unifying Runtime Adaptation and Design Evolution}},
	Url = {http://www.irisa.fr/triskell/publis/2009/Morin09b.pdf},
	X-Country = {CN},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Morin09b.pdf}}

@inproceedings{Morin09c,
	Abstract = {Domain-Specific Modeling Languages (DSMLs) describe the concepts of
	a particular domain and their relationships, in a meta-model. From
	a given DSML, it is possible to describe a wide range of different
	models. These models often share a common base and vary on some parts.
	Current approaches tend to distinguish the variability language from
	the DSMLs themselves, implying greater learning curve for DSMLs stakeholders
	and a significant overhead in product line engineering of DSLs. We
	propose to consider variability concepts as an independent aspect
	to be woven into the DSML to introduce variability capabilities.
	In particular we detail how variability is woven and how to perform
	product line derivation. We validate our approach through the weaving
	of variability into two very different metamodels: Ecore and SmartAdapter,
	our aspect-oriented modelling weaver, thus adding exibility in the
	weaving process itself. These results emphasize how new abilities
	of the language can be provided by this means.},
	Address = {Denver, Colorado, USA},
	Author = {Morin, Brice and Perrouin, Gilles and Lahire, Philippe and Barais, Olivier and Vanwormhoudt, Gilles and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {ACM/IEEE 12th International Conference on Model Driven Engineering Languages and Systems (MODELS'09)},
	Comment = {use_kermeta, cite_kermeta, en},
	Month = {Oct},
	Title = {{Weaving Variability into Domain Metamodels}},
	Url = {http://www.irisa.fr/triskell/publis/2009/Morin09c.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Pays = {LU},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Morin09c.pdf}}

@inproceedings{Morin09d,
	Abstract = {Since software systems need to be continuously available, their ability
	to evolve at runtime is a key issue. The emergence of models@runtime,
	combined with Aspect-Oriented Modeling techniques, is a promising
	approach to tame the complexity of adaptive systems. However, with
	no support for aspect unweaving, these approaches are not agile enough
	in an adaptive system context. In case of small modifications, the
	adapted model has to be generated by again weaving all the aspects,
	even those unchanged. This paper shows how aspects can be unwoven,
	based on a precise traceability metamodel dedicated to aspect model
	weaving. We analyze traceability models, which describe how aspects
	were woven into a base, to determine the extent to which an aspect
	has affected the woven model in order to determine how it can be
	unwoven. Aspect unweaving is finally performed by applying inverse
	operations of a sub-sequence of the weaving operations in opposite
	order.},
	Address = {Denver, Colorado, USA},
	Author = {Klein, Jacques and Kienzle, Jörg and Morin, Brice and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {ACM/IEEE 12th International Conference on Model Driven Engineering Languages and Systems (MODELS'09)},
	Comment = {use_kermeta, cite_kermeta, en},
	Month = {Oct},
	Title = {{Aspect Model Unweaving}},
	Url = {http://www.irisa.fr/triskell/publis/2009/Morin09d.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Pays = {LU,CA},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Morin09d.pdf}}

@inproceedings{Morin09e,
	Abstract = {This paper describes a demo which leverages models at designtime and
	runtime in the context of adaptive system, some details about the
	underlying approach as well as some implementation details. Our tool
	allows deploying and dynamically reconfiguring component-based applications,
	in a guided and safe way, based on the OSGi platform. It combines
	reflexive and generative programming techniques, based on models,
	to achieve this goal.},
	Address = {Denver, Colorado, USA},
	Author = {Morin, Brice and Nain, Gr{\'e}gory and Barais, Olivier and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {4th International Workshop on Models@Run.Time (at MODELS'09)},
	Comment = {cite_kermeta, en},
	Month = {Oct},
	Title = {{Leveraging Models From Design-time to Runtime. A Live Demo}},
	Url = {http://www.irisa.fr/triskell/publis/2009/Morin09e.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Morin09e.pdf}}

@article{Morin09f,
	Abstract = {An approach for specifying and executing dynamically adaptive software
	systems combines model-driven and aspect-oriented techniques to help
	engineers tame the complexity of such systems while offering a high
	degree of automation and validation.},
	Author = {Morin, Brice and Barais, Olivier and J{\'e}z{\'e}quel, Jean-Marc and Fleurey, Franck and Solberg, Arnor},
	Comment = {cite_kermeta, use_kermeta, en},
	Journal = {{IEEE} Computer},
	Month = {October},
	Pages = {46-53},
	Publisher = {IEEE Computer Society},
	Title = {Models at Runtime to Support Dynamic Adaptation},
	Url = {http://www.irisa.fr/triskell/publis/2009/Morin09f.pdf},
	X-Country = {US},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Pays = {NO},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Morin09f.pdf}}

@inproceedings{mouelhi09,
	Abstract = {In this paper, we consider typical applications in which the business
	logic is separated from the access control logic, implemented in
	an independent component, called the Policy Decision Point (PDP).
	The execution of functions in the business logic should thus include
	calls to the PDP, which grants or denies the access to the protected
	resources/functionalities of the system, depending on the way the
	PDP has been configured. The task of testing the correctness of the
	implementation of the security policy is tedious and costly. In this
	paper, we propose a new approach to reuse and automatically adapt
	existing functional test cases for specifically testing the security
	mechanisms. It includes a two step dynamic analysis technique based
	on mutation applied to security policies (RBAC, XACML, OrBAC). The
	method is applied to Java programs and provides tools for performing
	the two steps of the dynamic analyses. Three empirical case studies
	provide fruitful results and a first proof of concepts for this approach,
	e.g. by comparing its efficiency to an error-prone manual adaptation
	task.},
	Author = {Mouelhi, Tejeddine and Le Traon, Yves and Baudry, Benoit},
	Booktitle = {ICST},
	Month = {April},
	Title = {Transforming and selecting functional test cases for security policy testing},
	Url = {http://www.irisa.fr/triskell/publis/2009/mouelhi09.pdf},
	X-Country = {US},
	X-International-Audience = {yes},
	X-Language = {EN},
	address = {Denver, CO},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/mouelhi09.pdf}}

@inproceedings{muller09,
	Abstract = {Model-driven engineering and model-based approaches have permeated
	all branches of software engineering; to the point that it seems
	that we are using models, as Moli{\`e}re's Monsieur Jourdain was
	using prose, without knowing it. At the heart of modeling, there
	is a relation that we establish to represent something by something
	else. In this paper we review various definitions of models and relations
	between them. Then, we define a canonical set of relations that can
	be used to express various kinds of representation relations and
	we propose a graphical concrete syntax to represent these relations.
	Hence, this paper is a contribution towards a theory of modeling.},
	Address = {Denver, Colorado, USA},
	Author = {Muller, Pierre-Alain and Fondement, Fr{\'e}d{\'e}ric and Baudry, Benoit},
	Booktitle = {ACM/IEEE 12th International Conference on Model Driven Engineering Languages and Systems (MODELS'09)},
	Month = {October},
	Pages = {2-16},
	Title = {Modeling Modeling},
	Url = {http://www.irisa.fr/triskell/publis/2009/muller09.pdf},
	X-Country = {US},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/muller09.pdf}}

@inproceedings{munoz09a,
	Abstract = {Back in 2001, the MIT announced aspect-orientedprogramming as a key technology in the next 10 years.Nowadays, 8 years later, AOP is not widely adopted.Several reasons can explain this distrust in front ofAOP, and one of them is the lack of robust tools foranalysis, testing and maintenance. In order to developdedicated solutions for assisting the development withAOP, and increase its adoption, we need to understandhow it is actually used. In this paper we analyze 38aspect-oriented open source projects with respect tothe impact of aspects on the projects, and to coverageof the language features. This reveals that AOP iscurrently used in a cautious way. This work is a firststep to built support and development tools dedicatedto actual practices for AOP, based on empirical usage profiles.},
	Address = {Edmonton, Alberta, Canada},
	Author = {Munoz, Freddy and Baudry, Benoit and Delamare, Romain and Le Traon, Yves},
	Booktitle = {25th IEEE International Conference on Software Maintenance (ICSM'09)},
	Month = {Sep-Oct},
	Title = {{Inquiring the usage of aspect-oriented programming: an empirical study}},
	Url = {http://www.irisa.fr/triskell/publis/2009/munoz09a.pdf},
	X-Country = {CA},
	X-Editorial-Board = {yes},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/munoz09a.pdf}}

@inproceedings{munoz09b,
	Abstract = {Model composition helps designers managing complexities by modeling different system views separately, and later compose them into an integrated model. In the past years, researchers have focused on the definition of model composition approaches (operators) and the tools supporting them (model composition engines). Testing model composition engines is hard. It requires the synthesis and analysis of complex data structures (models). In this context, synthesis means to assembly complex structures in a coherent way with respect to semantic constraints. In this paper we propose to automatically synthesize input data for model composition engines using a model decomposition operator. Through this operator we synthesize models in a coherent way, satisfying semantic constraints and taking into account the complex mechanics involved in the model composition. Furthermore, such operator enables a straightforward analysis of the composition result.},
	Address = {Berlin, Heidelberg},
	Author = {Munoz, Freddy and Baudry, Benoit},
	Booktitle = {SC '09: Proceedings of the 8th International Conference on Software Composition},
	Doi = {http://dx.doi.org/10.1007/978-3-642-02655-3\_10},
	Isbn = {978-3-642-02654-6},
	Location = {Zurich, Switzerland},
	Pages = {125--141},
	Publisher = {Springer-Verlag},
	Title = {A Framework for Testing Model Composition Engines},
	Url = {http://www.irisa.fr/triskell/publis/2009/munoz09b.pdf},
	X-Country = {FR},
	X-Editorial-Board = {yes},
	X-International-Audience = {no},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/munoz09b.pdf},
	Bdsk-Url-2 = {http://dx.doi.org/10.1007/978-3-642-02655-3%5C_10}}

@techreport{munoz09c,
	Abstract = {Dynamically Adaptive Systems (DAS) are systems that modify their behavior and structure in response to changes in their surrounding environment. Critical mission systems increasingly incorporate adaptation and response to the environment; examples include disaster relief and space exploration systems. These systems can be decomposed in two parts: the adaptation policy that specifies how the system must react according to the environmental changes and the set of possible variants to reconfigure the system. A major challenge for testing these systems is the combinatorial explosions of variants and envi-ronment conditions to which the system must react. In this paper we focus on testing the adaption policy and propose a strategy for the selection of envi-ronmental variations that can reveal faults in the policy. Artificial Shaking Table Testing (ASTT) is a strategy inspired by shaking table testing (STT), a technique widely used in civil engineering to evaluate building's structural re-sistance to seismic events. ASTT makes use of artificial earthquakes that simu-late violent changes in the environmental conditions and stresses the system adaptation capability. We model the generation of artificial earthquakes as a search problem in which the goal is to optimize different types of envi-ronmental variations.},
	Address = {http://hal.inria.fr/inria-00365874/en/},
	Author = {Munoz, Freddy and Baudry, Benoit},
	Institution = {INRIA Bretagne Atlantique},
	Month = {March},
	Number = {inria-00365874},
	Title = {Artificial table testing dynamically adaptive systems},
	Type = {Research report},
	Type_Rapport = {Rapport de recherche},
	Url = {http://www.irisa.fr/triskell/publis/2009/munoz09c.pdf},
	X-Country = {FR},
	X-International-Audience = {no},
	X-Language = {EN},
	X-Proceedings = {no},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/munoz09c.pdf}}

@inproceedings{Nain09a,
	Abstract = { One of the society challenges of tomorrow is the aging population.
	Often pointed as a possible solution for this issue, house automation
	can help elderly people stay at home as long as possible, and ease
	the coordination of the domain actors. In this context, this paper
	lists the requirements of such a system, showing that today's commercial
	solutions are not flexible enough to reach the necessary functional
	richness. According to these requirements, a set of properties a
	middleware should offer in order to be deployed at a city scale is
	identified. Then this paper describes the software architecture of
	a suitable middleware built over OSGi, respecting the listed properties.
	After that, an experience report of the deployment of this middleware,
	in the laboratory of the Universit{\'e} de Rennes 1 highlights the relevance
	of the proposed solution.},
	Address = {Nancy, France},
	Author = {Nain, Gr{\'e}gory and Barais, Olivier and Fleurquin, R{\'e}gis and J{\'e}z{\'e}quel, Jean-Marc},
	Booktitle = {3{\`e}me Conf{\'e}rence Francophone sur les Architectures Logicielles (CAL'O9)},
	Comment = {fr},
	Month = mar,
	Title = {EntiMid : un middleware aux services de la maison},
	Url = {http://www.irisa.fr/triskell/publis/2009/Nain09a.pdf},
	X-Country = {FR},
	X-International-Audience = {no},
	X-Language = {FR},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Nain09a.pdf}}

@inproceedings{Perrouin09a,
	Abstract = {Ever-growing systems' complexity and novel requirements engineering
	approaches such as reuse or globalization imply that requirements
	are produced by different stakeholders and written in possibly different
	languages. In this context, checking consistency so that requirements
	specifications are amenable to formal analysis is a challenge. Current
	techniques either fail to consider the requirement set as a whole,
	missing certain inconsistency types or are unable to take heterogeneous
	(i.e. expressed in different languages) specifications into account.
	We propose to use model composition to address this problem in a
	staged approach. First, heterogeneous requirements are translated
	in model fragments instances of a common metamodel. Then, fragments
	are merged in one unique model. On such a model inconsistencies such
	as under-specifications can be incrementally detected and formal
	analysis is made possible. Our approach is fully supported by our
	model composition framework. We propose model composition as means
	to address flexibility needs in requirements integration. Threats
	to validity such as the impact of new requirements languages needs
	to be addressed in future work.},
	Address = {Amsterdam, Netherlands},
	Author = {Perrouin, Gilles and Brottier, Erwan and Baudry, Benoit and Le Traon, Yves},
	Booktitle = {Proceedings of the International Working Conference on Requirements Engineering: Foundation for Software Quality (REFSQ2009)},
	Comment = {en},
	Month = {june},
	Publisher = {Springer Lecture Notes in Computer Science (LNCS)},
	Title = {Composing Models for Detecting Inconsistencies: A Requirements Engineering Perspective},
	Url = {http://www.irisa.fr/triskell/publis/2009/Perrouin09a.pdf},
	X-Country = {NL},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Perrouin09a.pdf}}

@inproceedings{Sen09a,
	Abstract = {Testing model transformations requires input models which are graphs of inter-connected objects that must conform to a meta-model and meta-constraints from heterogeneous sources such as well-formedness rules, transformation pre-conditions, and test strategies. Manually specifying such models is tedious since models must simultaneously conform to several meta-constraints. We propose automatic model generation via constraint satisfaction using our tool Cartier for model transformation testing. Due to the virtually inÞnite number of models in the input domain we compare strategies based on input domain partitioning to guide model generation. We qualify the effectiveness of these strategies by performing mutation analysis on the transformation using generated sets of models. The test sets obtained using partitioning strategies gives mutation scores of up to 87\% vs. 72\% in the case of unguided/random generation. These scores are based on analysis of 360 automatically generated test models for the representative transformation of UML class diagram models to RDBMS models.},
	Address = {Zurich,Switzerland},
	Author = {Sen, Sagar and Baudry, Benoit and Mottu, Jean-Marie},
	Booktitle = {ICMT},
	Owner = {sagarsen},
	Timestamp = {2009.05.04},
	Title = {Automatic Model Generation Strategies for Model Transformation Testing},
	Url = {http://www.irisa.fr/triskell/publis/2009/Sen09a.pdf},
	X-Country = {CH},
	X-International-Audience = {yes},
	X-Language = {EN},
	X-Proceedings = {yes},
	Year = {2009},
	Bdsk-Url-1 = {http://www.irisa.fr/triskell/publis/2009/Sen09a.pdf}}

@article{Sen09c,
	Abstract = {Integrated development environments such as Eclipse allow users to write programs quickly by presenting a set of recommendations for code completion. Similarly, word processing tools such as Microsoft Word present corrections for grammatical errors in sentences. Both of these existing structure editors use a set of constraints expressed in the form of a natural language grammar to restrict/correct the user (syntax-directed editing) or formal grammar (language-directed editing) to aid document completion. Taking this idea further, in this paper we present an integrated software system capable of generating recommendations for model completion of partial models built in editors for domain-specific modeling languages.We present a methodology to synthesize model editors equipped with automatic completion from a modeling language's declarative specification consisting of a meta-model with a visual syntax. This meta-model directed completion feature is powered by a first-order relational logic engine implemented in ALLOY. We incorporate automatic completion in the generative tool AToM3. We use the finite state machines modeling language as a concise running example. Our approach leverages a correct by construction philosophy that renders subsequent simulation of models considerably less error-prone.
},