Stéphane Ducasse

Marcus Denker

Nicolas Anquetil

Damien Cassou

Anne Etien

Damien Pollet

Jean-Christophe Bach

Olivier Auverlot

Christophe Demarey

Guillaume Larcheveque

Esteban Lorenzano

Igor Stasenko

Clément Bera

Camillo Bruni

Andre Cavalcante Hora

Camille Teruel

Victor Martin Dias

Guillermo Polito

Gustavo Jansen

Souza Santos

Marco Naddeo

Vincent Blondeau

Cifre

Brice Morin

Cifre With Thales

Jean-Baptiste Arnaud

Stefan Marr

Ricardo Terra

Nunes Bueno

Abdelghani Alidra

Rafael Serapilha Durelli

Miguel Campusano

Visiting Phd

Luciana Silva

Julie Jonas

Benjamin Van Ryseghem

Kevin Lanvin

Hayatou Oumarou

Clara Allende

Pablo Herrero

Lucas Ariel Godoy

FUI Resilience]

Keywords: Software Engineering, Software Evolution, Maintenance, Reflective Programming Languages, Dynamic Languages Software evolution, Maintenance, Program visualization, Program analyses, Meta modelling, Software metrics, Quality models, Object-oriented programming, Reflective programming, Traits, Dynamically

typed languages, Smalltalk. RMoD's general vision is defined in two objectives: remodularization and modularity constructs. These two views are the two faces of a same coin: maintenance could be eased with better engineering and analysis tools and programming language constructs could let programmers define more modular applications.

Reengineering and remodularization

While applications must evolve to meet new requirements, few approaches analyze the implications of their original structure (modules, packages, classes) and their transformation to support their evolution. Our research will focus on the remodularization of object-oriented applications. Automated approaches including clustering algorithms are not satisfactory because they often ignore user inputs. Our vision is that we need better approaches to support the transformation of existing software. The reengineering challenge tackled by RMoD is formulated as follows:

How to help remodularize existing software applications?

We are developing analyses and algorithms to remodularize object-oriented applications. This is why we started studying and building tools to support the understanding of applications at the level of packages and modules. This allows us to understand the results of the analyses that we are building.

Constructs for modular and isolating programming languages

Dynamically-typed programming languages such as JavaScript are getting new attention as illustrated by the large investment of Google in the development of the Chrome V8 JavaScript engine and the development of a new dynamic language DART. This new trend is correlated to the increased adoption of dynamic programming languages for web-application development, as illustrated by Ruby on Rails, PHP and JavaScript. With web applications, users expect applications to be always available and getting updated on the fly. This continuous evolution of application is a real challenge [START_REF] Hicks | Dynamic software updating[END_REF]. Hot software evolution often requires reflective behavior and features. For instance in CLOS and Smalltalk each class modification automatically migrates existing instances on the fly.

At the same time, there is a need for software isolation i.e.,, applications should reliably run co-located with other applications in the same virtual machine with neither confidential information leaks nor vulnerabilities. Indeed, often for economical reasons, web servers run multiple applications on the same virtual machine. Users need confined applications. It is important that [START_REF] Anquetil | Software maintenance seen as a knowledge management issue[END_REF] an application does not access information of other applications running on the same virtual machine and [START_REF] Denker | Runtime Bytecode Transformation for Smalltalk[END_REF] an application authorized to manipulate data cannot pass such authorization or information to other parts of the application that should not get access to it. Static analysis tools have always been confronted to reflection [START_REF] Furr | Profile-guided static typing for dynamic scripting languages[END_REF]. Without a full treatment of reflection, static analysis tools are both incomplete and unsound. Incomplete because some parts of the program may not be included in the application call graph, and unsound because the static analysis does not take into account reflective features [START_REF] Livshits | DynaMine: finding common error patterns by mining software revision histories[END_REF]. In reflective languages such as F-Script, Ruby, Python, Lua, JavaScript, Smalltalk and Java (to a certain extent), it is possible to nearly change any aspect of an application: change objects, change classes dynamically, migrate instances, and even load untrusted code.

Reflection and isolation concerns are a priori antagonistic, pulling language design in two opposite directions. Isolation, on the one hand, pulls towards more static elements and types (e.g.,, ownership types). Reflection, on the other hand, pulls towards fully dynamic behavior. This tension is what makes this a real challenge: As experts in reflective programming, dynamic languages and modular systems, we believe that by working on this important tension we can make a breakthrough and propose innovative solutions in resolving or mitigating this tension. With this endeavor, we believe that we are working on a key challenge that can have an impact on future programming languages. The language construct challenge tackled by RMoD is formulated as follows:

What are the language modularity constructs to support isolation?

In parallel we are continuing our research effort on traits1 by assessing trait scalability and reuse on a large case study and developing a pure trait-based language. In addition, we dedicate efforts to remodularizing a meta-level architecture in the context of the design of an isolating dynamic language. Indeed at the extreme, modules and structural control of reflective features are the first steps towards flexible, dynamic, yet isolating, languages. As a result, we expect to demonstrate that having adequate composable units and scoping units will help the evolution and recomposition of an application.

Research Program

Software Reengineering

Strong coupling among the parts of an application severely hampers its evolution. Therefore, it is crucial to answer the following questions: How to support the substitution of certain parts while limiting the impact on others? How to identify reusable parts? How to modularize an object-oriented application?

Having good classes does not imply a good application layering, absence of cycles between packages and reuse of well-identified parts. Which notion of cohesion makes sense in presence of late-binding and programming frameworks? Indeed, frameworks define a context that can be extended by subclassing or composition: in this case, packages can have a low cohesion without being a problem for evolution. How to obtain algorithms that can be used on real cases? Which criteria should be selected for a given remodularization?

To help us answer these questions, we work on enriching Moose, our reengineering environment, with a new set of analyses [START_REF] Ducasse | Moose: a Collaborative and Extensible Reengineering Environment[END_REF], [START_REF] Ducasse | Using Smalltalk as a Reflective Executable Meta-Language[END_REF]. We decompose our approach in three main and potentially overlapping steps:

1. Tools for understanding applications, 2. Remodularization analyses, 3. Software Quality.

Tools for understanding applications

Context and Problems. We are studying the problems raised by the understanding of applications at a larger level of granularity such as packages or modules. We want to develop a set of conceptual tools to support this understanding. Some approaches based on Formal Concept Analysis (FCA) [START_REF] Snelting | Reengineering Class Hierarchies using Concept Analysis[END_REF] show that such an analysis can be used to identify modules. However the presented examples are too small and not representative of real code.

Research Agenda.

FCA provides an important approach in software reengineering for software understanding, design anomalies detection and correction, but it suffers from two problems: (i) it produces lattices that must be interpreted by the user according to his/her understanding of the technique and different elements of the graph; and, (ii) the lattice can rapidly become so big that one is overwhelmed by the mass of information and possibilities [START_REF] Anquetil | A Comparison of Graphs of Concept for Reverse Engineering[END_REF]. We look for solutions to help people putting FCA to real use.

Remodularization analyses

Context and Problems. It is a well-known practice to layer applications with bottom layers being more stable than top layers [START_REF] Martin | Agile Software Development. Principles, Patterns, and Practices[END_REF]. Until now, few works have attempted to identify layers in practice: Mudpie [START_REF] Vainsencher | MudPie: layers in the ball of mud[END_REF] is a first cut at identifying cycles between packages as well as package groups potentially representing layers. DSM (dependency structure matrix) [START_REF] Sullivan | The Structure and Value of Modularity in SOftware Design[END_REF], [START_REF] Sangal | Using Dependency Models to Manage Complex Software Architecture[END_REF] seems to be adapted for such a task but there is no serious empirical experience that validates this claim. From the side of remodularization algorithms, many were defined for procedural languages [START_REF] Koschke | Atomic Architectural Component Recovery for Program Understanding and Evolution[END_REF]. However, object-oriented programming languages bring some specific problems linked with late-binding and the fact that a package does not have to be systematically cohesive since it can be an extension of another one [START_REF] Wilde | Maintenance Support for Object-Oriented Programs[END_REF], [START_REF] Dunsmore | Object-Oriented Inspection in the Face of Delocalisation[END_REF].

As we are designing and evaluating algorithms and analyses to remodularize applications, we also need a way to understand and assess the results we are obtaining.

Research Agenda. We work on the following items: Layer identification. We propose an approach to identify layers based on a semi-automatic classification of package and class interrelationships that they contain. However, taking into account the wish or knowledge of the designer or maintainer should be supported.

Cohesion Metric Assessment. We are building a validation framework for cohesion/coupling metrics to determine whether they actually measure what they promise to. We are also compiling a number of traditional metrics for cohesion and coupling quality metrics to evaluate their relevance in a software quality setting.

Software Quality

Research Agenda. Since software quality is fuzzy by definition and a lot of parameters should be taken into account we consider that defining precisely a unique notion of software quality is definitively a Grail in the realm of software engineering. The question is still relevant and important. We work on the two following items:

Quality models. We studied existing quality models and the different options to combine indicatorsoften, software quality models happily combine metrics, but at the price of losing the explicit relationships between the indicator contributions. There is a need to combine the results of one metric over all the software components of a system, and there is also the need to combine different metric results for any software component. Different combination methods are possible that can give very different results. It is therefore important to understand the characteristics of each method.

Bug prevention. Another aspect of software quality is validating or monitoring the source code to avoid the emergence of well known sources of errors and bugs. We work on how to best identify such common errors, by trying to identify earlier markers of possible errors, or by helping identifying common errors that programmers did in the past.

Language Constructs for Modular Design

While the previous axis focuses on how to help remodularizing existing software, this second research axis aims at providing new language constructs to build more flexible and recomposable software. We will build on our work on traits [START_REF] Schärli | Traits: Composable Units of Behavior[END_REF], [START_REF] Ducasse | Traits: A Mechanism for fine-grained Reuse[END_REF] and classboxes [START_REF] Bergel | Classbox/J: Controlling the Scope of Change in Java[END_REF] but also start to work on new areas such as isolation in dynamic languages. We will work on the following points: (1) Traits and (2) Modularization as a support for isolation.

Traits-based program reuse

Context and Problems. Inheritance is well-known and accepted as a mechanism for reuse in object-oriented languages. Unfortunately, due to the coarse granularity of inheritance, it may be difficult to decompose an application into an optimal class hierarchy that maximizes software reuse. Existing schemes based on single inheritance, multiple inheritance, or mixins, all pose numerous problems for reuse.

To overcome these problems, we designed a new composition mechanism called Traits [START_REF] Schärli | Traits: Composable Units of Behavior[END_REF], [START_REF] Ducasse | Traits: A Mechanism for fine-grained Reuse[END_REF]. Traits are pure units of behavior that can be composed to form classes or other traits. The trait composition mechanism is an alternative to multiple or mixin inheritance in which the composer has full control over the trait composition. The result enables more reuse than single inheritance without introducing the drawbacks of multiple or mixin inheritance. Several extensions of the model have been proposed [START_REF] Denier | Traits Programming with AspectJ[END_REF], [START_REF] Quitslund | Java Traits -Improving Opportunities for Reuse[END_REF], [START_REF] Bergel | Stateful Traits[END_REF], [START_REF] Ducasse | User-Changeable Visibility: Resolving Unanticipated Name Clashes in Traits[END_REF] and several type systems were defined [START_REF] Fisher | Statically typed traits[END_REF], [START_REF] Smith | Chai: Typed Traits in Java[END_REF], [START_REF] Reppy | A Foundation for Trait-based Metaprogramming[END_REF], [START_REF] Liquori | FeatherTrait: A Modest Extension of Featherweight Java[END_REF].

Traits are reusable building blocks that can be explicitly composed to share methods across unrelated class hierarchies. In their original form, traits do not contain state and cannot express visibility control for methods. Two extensions, stateful traits and freezable traits, have been proposed to overcome these limitations. However, these extensions are complex both to use for software developers and to implement for language designers.

Research Agenda: Towards a pure trait language. We plan distinct actions: (1) a large application of traits, (2) assessment of the existing trait models and (3) bootstrapping a pure trait language.

• To evaluate the expressiveness of traits, some hierarchies were refactored, showing code reuse [START_REF] Black | Applying Traits to the Smalltalk Collection Hierarchy[END_REF]. However, such large refactorings, while valuable, may not exhibit all possible composition problems, since the hierarchies were previously expressed using single inheritance and following certain patterns. We want to redesign from scratch the collection library of Smalltalk (or part of it). Such a redesign should on the one hand demonstrate the added value of traits on a real large and redesigned library and on the other hand foster new ideas for the bootstrapping of a pure trait-based language.

In particular we want to reconsider the different models proposed (stateless [START_REF] Ducasse | Traits: A Mechanism for fine-grained Reuse[END_REF], stateful [START_REF] Bergel | Stateful Traits and their Formalization[END_REF], and freezable [START_REF] Ducasse | User-Changeable Visibility: Resolving Unanticipated Name Clashes in Traits[END_REF]) and their operators. We will compare these models by (1) implementing a trait-based collection hierarchy, (2) analyzing several existing applications that exhibit the need for traits. Traits may be flattened [START_REF] Nierstrasz | Flattening Traits[END_REF]. This is a fundamental property that confers to traits their simplicity and expressiveness over Eiffel's multiple inheritance. Keeping these aspects is one of our priority in forthcoming enhancements of traits. • Alternative trait models. This work revisits the problem of adding state and visibility control to traits.

Rather than extending the original trait model with additional operations, we use a fundamentally different approach by allowing traits to be lexically nested within other modules. This enables traits to express (shared) state and visibility control by hiding variables or methods in their lexical scope.

Although the traits' "flattening property" no longer holds when they can be lexically nested, the combination of traits with lexical nesting results in a simple and more expressive trait model. We formally specify the operational semantics of this combination. Lexically nested traits are fully implemented in AmbientTalk, where they are used among others in the development of a Morphiclike UI framework. • We want to evaluate how inheritance can be replaced by traits to form a new object model. For this purpose we will design a minimal reflective kernel, inspired first from ObjVlisp [START_REF] Cointe | Metaclasses are First Class: the ObjVlisp Model[END_REF] then from Smalltalk [START_REF] Goldberg | Smalltalk 80: the Interactive Programming Environment[END_REF].

Reconciling Dynamic Languages and Isolation

Context and Problems. More and more applications require dynamic behavior such as modification of their own execution (often implemented using reflective features [START_REF] Kiczales | Efficient Method Dispatch in PCL[END_REF]). For example, F-script allows one to script Cocoa Mac-OS X applications and Lua is used in Adobe Photoshop. Now in addition more and more applications are updated on the fly, potentially loading untrusted or broken code, which may be problematic for the system if the application is not properly isolated. Bytecode checking and static code analysis are used to enable isolation, but such approaches do not really work in presence of dynamic languages and reflective features. Therefore there is a tension between the need for flexibility and isolation.

Research Agenda: Isolation in dynamic and reflective languages. To solve this tension, we will work on Sure, a language where isolation is provided by construction: as an example, if the language does not offer field access and its reflective facilities are controlled, then the possibility to access and modify private data is controlled. In this context, layering and modularizing the meta-level [START_REF] Bracha | Mirrors: design principles for meta-level facilities of object-oriented programming languages[END_REF], as well as controlling the access to reflective features [START_REF] Caromel | Reflections on MOPs, Components, and Java Security[END_REF], [START_REF] Caromel | A security framework for reflective Java applications[END_REF] are important challenges. We plan to:

• Study the isolation abstractions available in erights (http://www.erights.org) [START_REF] Miller | Capability-based Financial Instruments[END_REF], [START_REF] Miller | Robust Composition: Towards a Unified Approach to Access Control and Concurrency Control[END_REF], and Java's class loader strategies [START_REF] Liang | Dynamic Class Loading in the Java Virtual Machine[END_REF], [START_REF] Gong | New security architectural directions for Java[END_REF]. • Categorize the different reflective features of languages such as CLOS [START_REF] Kiczales | The Art of the Metaobject Protocol[END_REF], Python and Smalltalk [START_REF] Rivard | Pour un lien d'instanciation dynamique dans les langages à classes[END_REF] and identify suitable isolation mechanisms and infrastructure [START_REF] Fong | Capabilities as alias control: Secure cooperation in dynamically extensible systems[END_REF]. • Assess different isolation models (access rights, capabilities [START_REF] Saltzer | The Protection of Information in Computer Systems[END_REF]...) and identify the ones adapted to our context as well as different access and right propagation. • Define a language based on -the decomposition and restructuring of the reflective features [START_REF] Bracha | Mirrors: design principles for meta-level facilities of object-oriented programming languages[END_REF], -the use of encapsulation policies as a basis to restrict the interfaces of the controlled objects [START_REF] Schärli | Object-oriented Encapsulation for Dynamically Typed Languages[END_REF], -the definition of method modifiers to support controlling encapsulation in the context of dynamic languages.

An open question is whether, instead of providing restricted interfaces, we could use traits to grant additional behavior to specific instances: without trait application, the instances would only exhibit default public behavior, but with additional traits applied, the instances would get extra behavior. We will develop Sure, a modular extension of the reflective kernel of Smalltalk (since it is one of the languages offering the largest set of reflective features such as pointer swapping, class changing, class definition...) [START_REF] Rivard | Pour un lien d'instanciation dynamique dans les langages à classes[END_REF].

Application Domains

Programming Languages and Tools

Many of the results of RMoD are improving programming languages or development tools for such languages.

As such the application domain of these results is as varied as the use of programming languages in general. Pharo, the language that RMoD develops, is used for a very broad range of applications. From pure research experiments to real world industrial use (the Pharo Consortium has over 10 company members) http://consortium.pharo.org Examples are web applications, server backends for mobile applications or even graphical tools and embedded applications.

Software Reengineering

Moose is a language-independent environment for reverse-and re-engineering complex software systems. Moose provides a set of services including a common meta-model, metrics evaluation and visualization. As such Moose is used for analysing software systems to support understanding and continous development as well as software quality analysis.

5. New Software and Platforms Here is the self-assessment of the team effort following the grid given at http://www.inria.fr/institut/ organisation/instances/commission-d-evaluation.

• (A5) Audience : 5 -Moose is used by several research groups, a consulting company, and some companies using it in ad-hoc ways. • (SO4) Software originality : 4 -Moose aggregates the last results of several research groups.

• (SM4) Software Maturity : 4 -Moose is developed since 1996 and got two main redesign phases.

• (EM4) Evolution and Maintenance : 4 -Moose will be used as a foundation of our Synectique start up so its maintenance is planned. Web: http://www.pharo.org/

The platform.

Pharo is an open-source Smalltalk-inspired language and environment. It provides a platform for innovative development both in industry and research. By providing a stable and small core system, excellent developer tools, and maintained releases, Pharo's goal is to be a platform to build and deploy mission critical applications, while at the same time continue to evolve.

The first stable version, Pharo 1.0, was released in 2010. We are now releasing one new version of Pharo every year, with Pharo3 released in spring 2014. Pharo4 has seen already over 400 incremental updates and is scheduled for early 2015. It should be noted that Pharo, even though already used outside of research, still continues to improve radically.

In November 2012 RMoD launched the Pharo Consortium (http://consortium.pharo.org/) and the Pharo Association (http://association.pharo.org). The consortium has now 14 industrial members, 3 sponsors and 10 academic partners.

RMoD is the main maintainer and coordinator of Pharo.

Here is the self-assessment of the team effort following the grid given at http://www.inria.fr/institut/ organisation/instances/commission-d-evaluation.

• (A5) Audience: 5 -Used in many universities for teaching, more than 25 companies.

• • RMOD entered in a sponsoring agreement with LAM Research, Inc.

Tools for understanding applications

Remodularization Analysis Using Semantic Clustering. We report an experience on using and adapting Semantic Clustering to evaluate software remodularizations. Semantic Clustering is an approach that relies on information retrieval and clustering techniques to extract sets of similar classes in a system, according to their vocabularies. We adapted Semantic Clustering to support remodularization analysis. We evaluate our adaptation using six real-world remodularizations of four software systems. We report that Semantic Clustering and conceptual metrics can be used to express and explain the intention of the architects when performing common modularization operators, such as module decomposition. [START_REF] Santos | Remodularization Analysis Using Semantic Clustering[END_REF] Towards a new package dependency model. Smalltalk originally did not have a package manager. Each Smalltalk implementation defined its own with more or less functionalities. Since 2010, Monticello/Metacello[Hen09] one package manager is available for open-source Smalltalks. It allows one to load source code packages with their dependencies. This package manager does not have all features we can find in well-known package managers like those used for the Linux operating system. We identify the missing features and propose a solution to reach a full-featured package manager. A part of this solution is to represent packages and dependencies as first-class objects, leading to the definition of a new dependency model. [START_REF] Demarey | Towards a new package dependency model[END_REF] A Domain Specific Aspect Language for IDE Events. Integrated development environments (IDEs) have become the primary way to develop software. Besides just using the built-in features, it becomes more and more important to be able to extend the IDE with new features and extensions. Plugin architectures exist, but they show weaknesses related to unanticipated extensions and event handling. We argue that a more general solution for extending IDEs is needed. We present and discuss a solution, motivated by a set of concrete examples: a domain specific aspect language for IDE events. In it, join points are events of interest that may trigger the advice in which the behavior of the IDE extension is called. We show how this allows for the development of IDE plugins and demonstrate the advantages over traditional publish/subscribe systems. [START_REF] Fabry | DIE: A Domain Specific Aspect Language for IDE Events[END_REF] AspectMaps: Extending Moose to visualize AOP software. When using aspect-oriented programming the application implicitly invokes the functionality contained in the aspects. Consequently program comprehension of such a software is more intricate. To alleviate this difficulty we developed the AspectMaps visualization and tool. AspectMaps extends the Moose program comprehension and reverse engineering platform with support for aspects, and is implemented using facilities provided by Moose. We present the AspectMaps tool, and show how it can be used by performing an exploration of a fairly large aspect-oriented application.

We then show how we extended the FAMIX meta-model family that underpins Moose to also provide support for aspects. This extension is called ASPIX, and thanks to this enhancement Moose can now also treat aspect-oriented software. Finally, we report on our experiences using some of the tools in Moose; Mondrian to implement the visualization, and Glamour to build the user interface. We discuss how we were able to implement a sizable visualization tool using them and how we were able to deal with some of their limitations.

[20]

6.3. Software Quality: Taming Software Evolution APIEvolutionMiner: Keeping API Evolution under Control. During software evolution, source code is constantly refactored. In real-world migrations, many methods in the newer version are not present in the old version (e.g., 60% of the methods in Eclipse 2.0 were not in version 1.0). This requires changes to be consistently applied to reflect the new API and avoid further maintenance problems. We propose a tool to extract rules by monitoring API changes applied in source code during system evolution. In this process, changes are mined at revision level in code history. Our tool focuses on mining invocation changes to keep track of how they are evolving. We also provide three case studies in order to evaluate the tool. [START_REF] Hora | APIEvolutionMiner: Keeping API Evolution under Control[END_REF] Towards an Automation of the Mutation Analysis Dedicated to Model Transformation. A major benefit of Model Driven Engineering (MDE) relies on the automatic generation of artefacts from high-level models through intermediary levels using model transformations. In such a process, the input must be well-designed and the model transformations should be trustworthy. Due to the specificities of models and transformations, classical software test techniques have to be adapted. Among these techniques, mutation analysis has been ported and a set of mutation operators has been defined. However, mutation analysis currently requires a considerable manual work and suffers from the test data set improvement activity. This activity is seen by testers as a difficult and time-consuming job, and reduces the benefits of the mutation analysis. This work addresses the test data set improvement activity. Model transformation traceability in conjunction with a model of mutation operators, and a dedicated algorithm allow to automatically or semi-automatically produce test models that detect new faults. The proposed approach is validated and illustrated in a case study written in Kermeta. [START_REF] Aranega | Towards an Automation of the Mutation Analysis Dedicated to Model Transformation[END_REF] Predicting software defects with causality tests. We propose a defect prediction approach centered on more robust evidences towards causality between source code metrics (as predictors) and the occurrence of defects.

More specifically, we rely on the Granger causality test to evaluate whether past variations in source code metrics values can be used to forecast changes in time series of defects. Our approach triggers alarms when changes made to the source code of a target system have a high chance of producing defects. We evaluated our approach in several life stages of four Java-based systems. We reached an average precision greater than 50% in three out of the four systems we evaluated. Moreover, by comparing our approach with baselines that are not based on causality tests, it achieved a better precision. [START_REF] Couto | Predicting software defects with causality tests[END_REF] 6.4. Software Quality: History and Changes

Tracking dependencies between code changes: An incremental approach. Merging a change often leads to the question of knowing what are the dependencies to other changes that should be merged too to obtain a working system. This question also arises with code history trackers -Code history trackers are tools that react to what the developer do by creating first-class objects that represent the change made to the system. We evaluate the capacity of different code history trackers to represent, also as first-class objects, the dependencies between those changes. We also present a representation for dependencies that works with the event model of Epicea, a fine-grained and incremental code history tracker. [START_REF] Demarey | Towards a new package dependency model[END_REF] Mining Architectural Violations from Version History. Software architecture conformance is a key software quality control activity that aims to reveal the progressive gap normally observed between concrete and planned software architectures. However, formally specifying an architecture can be difficult, as it must be done by an expert of the system having a high level understanding of it. We present a lightweighted approach for architecture conformance based on a combination of static and historical source code analysis.

The proposed approach relies on four heuristics for detecting absences (something expected was not found) and divergences (something prohibited was found) in source code based architectures. We also present an architecture conformance process based on the proposed approach. We followed this process to evaluate the architecture of two industrial-strength information systems, achieving an overall precision of 62.7% and 53.8%. We also evaluated our approach in an open-source information retrieval library, achieving an overall precision of 59.2%. We envision that aheuristic-based approach for architecture conformance can be used to rapidly raise architectural warnings, without deeply involving experts in the process. [START_REF] Maffort | Mining Architectural Violations from Version History[END_REF] 6.

Reconciling Dynamic Languages and Isolation

Delegation Proxies: The Power of Propagation. Scoping behavioral variations to dynamic extents is useful to support non-functional requirements that otherwise result in cross-cutting code. Unfortunately, such variations are difficult to achieve with traditional reflection or aspects. We show that with a modification of dynamic proxies, called delegation proxies, it becomes possible to reflectively implement variations that propagate to all objects accessed in the dynamic extent of a message send. We demonstrate our approach with examples of variations scoped to dynamic extents that help simplify code related to safety, reliability, and monitoring. [START_REF] Wernli | Delegation Proxies: The Power of Propagation[END_REF] Reifying the Reflectogram. Reflective facilities in OO languages are used both for implementing language extensions (such as AOP frameworks) and for supporting new programming tools and methodologies (such as object-centric debugging and message-based profiling). Yet controlling the run-time behavior of these reflective facilities introduces several challenges, such as computational overhead, the possibility of metarecursion and an unclean separation of concerns between base and meta-level. We present five dimensions of meta-level control from related literature that try to remedy these problems. These dimensions are namely: temporal and spatial control, placement control, level control and identity control. We argue that the reification of the descriptive notion of the reflectogram, can unify the control of meta-level execution in all these five dimensions. We present a model for the reification of the reflectogram and validate our approach through a prototype implementation in the Pharo programming environment. Finally we detail a case study on run-time tracing illustrating our approach. [START_REF] Papoulias | Reifying the Reflectogram[END_REF] Bootstrapping Reflective Systems: The Case of Pharo. Bootstrapping is a technique commonly known by its usage in language definition by the introduction of a compiler written in the same language it compiles. This process is important to understand and modify the definition of a given language using the same language, taking benefit of the abstractions and expression power it provides. A bootstrap, then, supports the evolution of a language. However, the infrastructure of reflective systems like Smalltalk includes, in addition to a compiler, an environment with several self-references. A reflective system bootstrap should consider all its infrastructural components. We propose a definition of bootstrap for object-oriented reflective systems, we describe the architecture and components it should contain and we analyze the challenges it has to overcome. Finally, we present a reference bootstrap process for a reflective system and Hazelnut, its implementation for bootstrapping the Pharo Smalltalk-inspired system. [START_REF] Polito | Bootstrapping Reflective Systems: The Case of Pharo[END_REF] 6.6. Dynamic Languages: Virtual Machines Benzo: Reflective Glue for Low-level Programming. The goal of high-level low-level programming is to bring the abstraction capabilities of high-level languages to the system programming domain, such as virtual machines (VMs) and language runtimes. However, existing solutions are bound to compilation time and expose limited possibilities to be changed at runtime and from language-side. They do not fit well with fully reflective languages and environments. We propose Benzo1, a lightweight framework for high-level low-level programming that allows developers to generate and execute at runtime low-level code. It promotes the implementation, and dynamic modification, of system components with high-level language tools outperforming existing dynamic solutions. Since Benzo is a general framework we choose three applications that cover an important range of the spectrum of system programming for validating the infrastructure: a Foreign Function Interface (FFI), primitives instrumentation and a just-in-time bytecode compiler (JIT). With Benzo we show that these typical VM-level components are feasible as reflective language-side implementations. Due to its unique combination of high-level reflection and low-level programming, Benzo shows better performance for these three applications than the comparable high-level implementations. [START_REF] Bruni | Benzo: Reflective Glue for Low-level Programming[END_REF] A bytecode set for adaptive optimizations. The Cog virtual machine features a bytecode interpreter and a baseline Just-in-time compiler. To reach the performance level of industrial quality virtual machines such as Java HotSpot, it needs to employ an adaptive inlining com-piler, a tool that on the fly aggressively optimizes frequently executed portions of code. We decided to implement such a tool as a bytecode to bytecode optimizer, implemented above the virtual machine, where it can be written and developed in Smalltalk. The optimizer we plan needs to extend the operations encoded in the bytecode set and its quality heavily depends on the bytecode set quality. The current bytecode set understood by the virtual machine is old and lacks any room to add new operations. We decided to implement a new bytecode set, which includes additional bytecodes that allow the Just-in-time compiler to generate less generic, and hence simpler and faster code sequences for frequently executed primitives. The new bytecode set includes traps for validating speculative inlining de-cisions and is extensible without compromising optimization opportunities. In addition, we took advantage of this work to solve limitations of the current bytecode set such as the maximum number of instance variable per class, or number of literals per method. We plan to have it in production in the Cog virtual machine and its Pharo, Squeak and Newspeak clients in the coming year.

[43]

Traits

Trait-oriented Programming in Java 8 Java 8 was released recently. Along with lambda expressions, a new language construct is introduced: default methods in interfaces. The intent of this feature is to allow interfaces to be extended over time preserving backward compatibility. We show a possible, different use of interfaces with default methods: we introduce a trait-oriented programming style based on an interface-as-trait idea, with the aim of improving code modularity. Starting from the most common operators on traits, we introduce some programming patterns mimicking such operators and discuss this approach. [START_REF] Bono | Trait-oriented Programming in Java 8[END_REF] 6.8. Tailoring Applications

In the context of the PhD of G. Polito, we developed Tornado, a way to generate specialized and minimal runtime. Using a run-fail-grow approach, which tries to execute an expression in an empty world, and on failure copies the missing program elements from a mother environment to the currently empty world, we could grew 11k full reflective application adding two numbers or 18k for the 100 factorial expression. We also usd this approach to generate specialized webserver in around 500kb. These results show that we can generate hyperspecialized kernels. Contracting parties: CEA, Evitech, Inria, Logilab, Opida, Thales, Wallix.

Bilateral Contracts and Grants with Industry

Beyond embedded computing, there is not so much research and development on the verification of software safety. Recently, some tools have been created for languages such as JAVA, SQL, VB or PHP. Nevertheless, nothing exists for Python even though this language is growing fast. SafePython's goal is to provide code analysis tools applicable to Python programs. This project will define a subset of Python that the developers will have to use to have their programs analyzed. In the context of a CIFRE PhD we are working on large industrial project characterization. The PhD started in October 2014.

Pharo Consortium

The Pharo Consortium was founded in 2012 and is growing constantly. As of end 2014, it has 14 company members, 10 academic partners and 3 sponsoring companies. Inria supports the consortium with one full time engineer starting in 2011. More at http://consortium.pharo.org.

Partnerships and Cooperations

Regional Initiatives

We have signed a convention with the CAR team led by Noury Bouraqadi of Ecole des Mines de Douai.

In such context we co-supervized two PhD students (Mariano Martinez-Peck, Nick Papoylias). Two cosupervisions are ongoing (Guillermo Polito, Max Mattone). The team is also an important contributor and supporting organization of the Pharo project. We are involved in the ERCIM Software Evolution working group since its inception. We participated at his creation when we were at the University of Bern. We are collaborating with ObjectProfile, a startup company which is hosted at Inria Chile. ObjectProfile is a collaborator within the PLOMO2 Associated Team and a contributor to both Pharo and Moose. http:// objectprofile.com

National Initiatives

International Initiatives

The DeepIntoPharo book is a collaboration with the Pleiad Team of University of Chile at Santiago.

  • (SDL4) Software Distribution and Licensing : 4 -Moose is licensed under BSD • (OC) Own Contribution : (Design/Architecture)DA-4, (Coding/Debugging)-4, (Maintenance/Support)-4, (Team/Project Management)-4 5.2. Pharo3.0 Participants: Marcus Denker [correspondant], Damien Cassou, Stéphane Ducasse, Esteban Lorenzano, Damien Pollet, Igor Stasenko, Camillo Bruni, Camille Teruel, Clément Bera.

5 5. 3 .

 53 SO3) Software originality : 3 -Pharo offers a classical basis for some aspects (UI). It includes new frameworks and concepts compared to other Smalltalk implementations. • (SM4) Software Maturity: 4 -Bug tracker, continuous integration, large test suites are in place. • (EM4) Evolution and Maintenance: 4 -Active user group, consortium and association has been set up. • (SDL4) Software Distribution and Licensing: 4 -Pharo is licensed under MIT. • (OC5) Own Contribution: (Design/Architecture) DA-5, (Coding/Debugging) CD-5, (Maintenance/Support) MS-5, (Team/Project Management) TPM-Pillar 0.17

  Pillar is a markup syntax and associated tools to write and generate documentation and books. Pillar is currently used to write several books and other documentation. Two platforms have already been created on top of Pillar: PillarHub and Marina. http://www.smalltalkhub.com/#!/~Pier/Pillar 6. New Results6.1. Highlights of the Year• Pharo 3.0 has been released in April 2014. • Moose 5.0 has been released in December 2014. • The book Deep into Pharo has been released publicly http://www.deepintopharo.com.

7. 1 .

 1 SafePython FUI Participants: Damien Cassou [Correspondant], Jean-Baptiste Arnaud, Stephane Ducasse.

7. 4 .

 4 Worldline CIFRE Participants: Anne Etien [Correspondant], Nicolas Anquetil, Stéphane Ducasse, Vincent Blondeau.

8. 4 . 1 .

 41 Inria International Labs CIRIC Chile and Pleiad Team of University of Chile at Santiago

  The platform. Moose is a language-independent environment for reverse-and re-engineering complex software systems. Moose provides a set of services including a common meta-model, metrics evaluation and visualization, a model repository, and generic GUI support for querying, browsing and grouping. The development of Moose began at the Software Composition Group in 1997, and is currently contributed to and used by researchers in at least seven European universities. Moose offers an extensible meta-described metamodel, a query engine, a metric engine and several visualizations. Moose is currently in its fourth major release and comprises 55,000 lines of code in 700 classes.The RMoD team is currently the main maintainer of the Moose platform. There are 200 publications (journal, international conferences, PhD theses) based on execution or use of the Moose environment.The first version running on top of Pharo (Moose 4.0) was released in June 2010. The current focus is Moose 5.0, in late beta testing as of December 2014. A major development of 2014 is that tools and frameworks built for Moose are being integrated into Pharo4 as the default development tools.

	5.1. Moose5.0

Participants: Stéphane Ducasse [correspondant], Muhammad Bhatti, Andre Calvante Hora, Nicolas Anquetil, Anne Etien, Guillaume Larcheveque, Tudor Gîrba [University of Bern].

Web: http://www.moosetechnology.org/

  Contracting parties: Nexedi, Morphom Alcatel-Lucent Bell Labs, Astrium Geo Information, Wallix, XWiki, Alixen, Alterway, Institut Télécom, Université Paris 13, CEA LIST.Resilience's goal is to protect private data on the cloud, to reduce spying and data loss in case of natural problems. Resilience proposes to develop a decentralized cloud architecture: SafeOS. Safe OS is based on replication of servers. In addition a safe solution for documents should be developed. Sandboxing for Javascript applications should be explored.We proposed to use WebWorkers as a way to control DOM edition. There is a plethora of research articles describing the deep semantics of JavaScript. Nevertheless, such articles are often difficult to grasp for readers not familiar with formal semantics. We proposed a digest of the semantics of JavaScript centered around security concerns.

	7.2. Sponsoring LAM
	Participants: Stéphane Ducasse [Correspondant], Marcus Denker.
	Contracting parties: Inria, LAM Research, Inc.
	LAM Research Inc.(http://lamrc.com) is a leading supplier of wafer fabrication equipment and services to the
	global semiconductor industry. LAM has started to sponsor RMOD in 2014. RMOD used the sponsored funds
	to pay student internships in 2014.
	7.3. Resilience FUI
	Participants: Stéphane Ducasse [Correspondant], Nicolas Petton, Damien Cassou.

  CUTTER is a Basic Research project that addresses the problems of object-oriented system remodularization by developing, combining, and evaluating new techniques for analyzing and modularizing code. In particular, it will: (i) use concurrently and collaboratively four package decomposition techniques; and (ii) take into account different levels of abstractions (packages, classes). Mobility between Europe and Argentina applying Logics to Systems) is a mobility project financed by the 7th Framework programme under Marie Curie's International Research Staff Exchange Scheme. It involves seven academic institutions from Europe and four from Argentina, and a total of about 80 researchers to be exchanged. The project started on the 1st of October, 2011, and it has a duration of 4 years.

	The project started in march 2011 and ended this year in November just after the defense of PhD student André
	Hora
	8.3. European Initiatives
	8.3.1. FP7 & H2020 Projects
	MEALS FP7 Marie Curie Research Staff Exchange Scheme
	MEALS (Nr: FP7-
	PEOPEL-2011-IRSES
	http://www.meals-project.eu
	8.3.2. Collaborations in European Programs, except FP7 & H2020
	8.2.1. ANR
	8.2.1.1. Cutter
	Participants: Stéphane Ducasse [Correspondant], Nicolas Anquetil, Damien Pollet, Muhammad Bhatti,
	Andre Calvante Hora.

This partnernship is done with the following members from the LIRMM-D'OC-APR: Marianne Huchard, Roland Ducournau, Jean-Claude König, Rodolphe Giroudeau, Abdelhak-Djamel Seriai, and Rémi Watrigant.

8.3.2.1. ERCIM Software Evolution

  International Workshop on Smalltalk Technologies. -COP 2014, ECOOP International Workshop on Context-Oriented Programming • Stéphane Ducasse declined the participation to ECOOP 2014 and ECOOP 2015. 9.1.2.2. Reviewer • Damien Cassou: Apsec 2014 The Asia-Pacific Software Engineering Conference • Martin Dias: ICSME 2014 International Conference on Software Maintenance and Evolution • Andre Hora: ICSME 2014 and SANER 2014 International Conference on Software Analysis, Evolution, and Reengineering 9.1.3. Journal 9.1.3.1. Reviewer • Anne Etien: International Journal of Computer Aided Engineering and Technology (IJCAET) • Damien Cassou reviewed paper for SCP 9.2. Teaching -Supervision -Juries 9.2.1. Teaching Master: C. Demarey, Architectures Logicielles, 30h (M1), GIS4, Polytech'Lille, France PhD in progress: Camille Teruel, Security for dynamic languages, 01/12/2012, Stéphane Ducasse, Damien Cassou PhD in progress: Martin Dias, Supporting Merging, 03/12/2012, Damien Cassou, Stéphane Ducasse. PhD in progress: Guillermo Polito, Isolation and Reflection in Dynamic Object Oriented Languages, 01/04/2012, Noury Bouraqadi, Luc Fabresse, Stéphane Ducasse. PhD in progress: Marco Naddeo, Viviana Bono (Univerosty of Turin), Damien Cassou, Stéphane Ducasse, started 01/01/2014 PhD in progress: Vincent Blondeau, CIFRE Worldline, started Oct 2014, Anne Etien, Nicolas Anquetil. PhD in progress: Brice Govin, CIFRE Thales, started Jan 2015, Anne Etien, Nicolas Anquetil, Stéphane Ducasse. PhD in progress: Max Mattone: Updating programs at runtime, started Oct 2014 Noury Bouraqadi, Luc Fabresse, Stéphane Ducasse . PhD in progress: Clement Bera: Evolvable Runtimes for a Changing World, started Oct 2014, Stéphane Ducasse, Marcus Denker. 9.2.3. Juries • Nicolas Anquetil: Lisong Guo, LIP6 University Pierre and Marie Currie, 12/2014 (reviewer) • Damien Cassou: Eyvind W. Axelsen, Oslo, 05/2014 (opponent) • Stéphane Ducasse: Une approche pragmatique pour mesurer la qualité des applications à base de composants logiciels, Salma Hamza, Université de Bretagne Sud, France. 18/12/14. (referee) • Anne Etien was in the mid term examination committee of the PhD thesis: Elie Richa 09/2014 (reviewer) 9.3. Popularization • Marcus Denker gave two presentations about Pharo at the open source conference FOSDEM 2014. • Damien Cassou gave a Pharo tutorial at PLDI'14. • RIC Day was held 23 September 2014 @ University of Lille 1, Lille, Anne Etien and Damien Pollet gave a presentation about Pharo, Moose and software maintenance. • A Programming Dojo was organized by Christophe Demarey on Dec 1st. • A hands-on course about Pharo for the students at Lille in November organized by Léo Perard and Stéphane Ducasse. • Demo for industry at the Rencontres Inria-Industrie Technologies du Web, 26 Nov 2014 at EuraTechnologies -Lille. • RMOD co-organized and participated at ESUG 2014. • Multiple public Pharo Sprints in Lille. • Stefan Marr gave a half-day tutorial on "Building Self-Optimizing Interpreters with Truffle or RPython" at the Software Composition Group, Universität Bern, Switzerland, December 2nd, 2014 • Stefan Marr gave an invited talk on "Building High-Performance Language Implementations with Low Effort" at Software Composition Group, Universität Bern, Switzerland, December 1st, 2014 • Stefan Marr gave an invited talk on "Zero-Overhead Metaprogramming: Using Self-Optimizing Interpreters to Remove the Runtime Cost of Reflective Programming" at the Software Languages Lab, Vrije Universiteit Brussel, Belgium, November 2014 • Stefan Marr gave an invited talk "On the Way to Concurrency without Accidental Complexity" at the Institut für Systemsoftware, JKU University Linz, Austria, July 2014 • Stefan Marr gave an invited talk on "Building VMs for Language Designers" at the Software Development Team of Laurence Tratt, King's College London, May 2014 • Stefan Marr gave a talk on "How to get a JIT Compiler for Free?" in the Smalltalk Developer Room of the FOSDEM Open Source Conference, Brussels, Belgium, February 2014 10. Bibliography Major publications by the team in recent years

	9. Dissemination
	9.1. Promoting Scientific Activities
	9.1.1. Scientific events organisation
	9.1.1.1. Member of the organizing committee
	• Marcus Denker, Damien Cassou and Stéphane Ducasse where part of the organization of ESUG
	2014.
	• Damien Cassou co-organized Dyla'14 Workshop on Dynamic Languages and Applications
	9.1.2. Scientific events selection
	9.1.2.1. Member of the conference program committee
	• Anne Etien
	-ECMFA 2014, European Conference on Modelling Foundations and Applications.
	-IWST 2014, International Workshop on Smalltalk Technologies.
	-ME 2014, Models and Evolution
	-SLE 2014, International Conference on Software Language Engineering.
	-Dyla'14, Workshop on Dynamic Languages and Applications
	-Inforsid 14 Congrès INFORSID -INFormatique des ORganisations et Systèmes
	d'Information et de Décision
	• Damien Cassou
	-Dyla'14, Workshop on Dynamic Languages and Applications
	• Stefan Marr
	-DLS 2014, Dynamic Langauge Symposium
	-9th ICOOOLPS 2014 Workshop Implementation, Compilation, Optimization of OO Lan-
	guages, Programs and Systems.
	• Marcus Denker
	-IWST 2014,
	8.4.2. Inria Associate Teams
	8.4.2.1. PLOMO2
	Title: Infrastructure for a new generation of development tools
	International Partner:
	Universidad de Chile (Chile), DCC.
	Duration: 2014 -2016
	See also: http://pleiad.cl/research/plomo2
	Performing effective software development and maintenance are best achieved with effective tool
	support. Provided by a variety of tools, each one presenting a specific kind of information supporting
	the task at hand. The goal of the first PLOMO was to develop new meta tools to improve and bring
	synergy in the existing infrastructure of Pharo (for software development) and the Moose software
	analysis platform (for maintenance). With Plomo2, we want to build on top of this work and invent
	a new generation of tools to navigate and profile programs.
	The hypotheses that Plomo2 will seek to verify are:
	• Use of reflection enables new profiling techniques

Traits are groups of methods that can be composed orthogonally to simple inheritance. Contrary to mixin, the class has the control of the composition and conflict management.

• Use of visualization in a programming environment improves programmer performance The overall objectives of Plomo2 are:

• Infrastructure for profiling programs and recording programmer activity.

• Visual software maps defined in a flexible and agile fashion • Combining dynamic information with visualization to improve the development environment • Empirical evaluation of this environment • All the efforts will be performed on Pharo and Moose, two platforms heavily used by the RMoD and Pleiad teams.

The detailed work plan and the results of the first year can be found in the PLOMO2 report at http://pleiad.cl/research/plomo2. This project aims at facilitating the usage of frameworks and application programming interfaces (APIs) by mining software repositories. Our intuition is that mining reveals how existing projects instantiate these frameworks. By locating concrete framework instantiations in existing projects, we can recommend to developers the concrete procedures for how to use a particular framework for a particular task in a new system. Our project also tackles the challenge of adapting existing systems to new versions of a framework or API by seeking repositories for how other systems adapted to such changes. We plan to integrate recommendations of how to instantiate a framework and adapt to changes directly in the development environment. Those points taken together, considerably distinguish our approach from existing research in the area of framework engineering.

European Lab with Delft

We have a Lille Nord Europe European Lab with A. Bachelli from Delft University. We are working on infrastructure and tools for code reviewing. We have exchange of staff and got a paper accepted to SANER 2015.

International Research Visitors

Visits of International Scientists

In the context of the PLOMO2 associated Team with the University of Chile:

• Ronie Saldago: 24/08/2014 until 07/09/2014. Subject was FFI and OSWindow.


Renaud Bourlès
email: renaud.bourles@centrale-marseille.fr

Gilbert Cette
email: gilbert.cette@banque-france.fr

Jimmy Lopez
email: jimmy.lopez@banque-france.fr

Jacques Mairesse
email: jacques.mairesse@ensae.fr

Giuseppe Nicoletti
email: giuseppe.nicoletti@oecd.org

Forum THE IMPACT ON GROWTH OF EASING REGULATIONS IN UPSTREAM SECTORS

. The illustrative simulations given here are different, however, from those of the study. The views expressed in the paper are those of the authors and do not necessarily reflect those of Banque de France, the OECD or its member countries.

Introduction 1

The need to find ways to boost GDP growth is particularly important in the recovery from the current recession. The implementation of structural reforms aiming at decreasing anti-competitive regulations may be one of them. The multifactor productivity (MFP) gains obtained from such reforms could improve significantly potential output growth, thereby also facilitating the adjustment of public finances, which have suffered from the crisis and the ensuing recovery plans. We document in this paper some simulations, which are based on estimates of a "neo-Shumpeterian" model and tend to show that important MFP growth gains could be obtained in developed countries by adopting best regulation practices in "upstream sectors", i.e., sectors that are chief providers of intermediate inputs to the economy.

We first describe two main channels through which the lack of competition in sectors providing interme-diate inputs (henceforth upstream sectors) can affect efficiency growth in downstream sectors, by proposing an extension of the "neo-Schumpeterian" endogenous growth model of [START_REF] Aghion | Competition and Growth with Step-by-Step Innovation: An Example[END_REF].

We then present the econometric model we use to test the existence and estimate the importance of such upstream anti-competitive effects. Next, we describe our country-sector MFP and regulation data, and discuss our main empirical results and the related robustness checks. Finally, based on these results, we provide some illustrative simulations of the potential effects of policy reforms increasing competition in upstream markets.

Two channels

A large and growing body of research has studied the effects of competition on growth (for a survey, see Aghion and Griffith 2005). While competition can affect economic performance through various channels, this line of research has usually focused on the direct effects of a lack of competition in a sector on its productivity performance. We focus here on the effects of regulations that curb market competition in upstream sectors, such as legal barriers to entry in non-manufacturing markets, on the productivity performance of downstream sectors.

We distinguish two main channels through which lack of competition in upstream sectors can generate "trickle-down effects" that affect the productivity performance of other sectors. Firstly, anti-competitive regulations in an upstream sector can reduce competition downstream if access to downstream markets requires using intermediate inputs produced upstream, particularly in the case of services inputs where import competition is limited. For example, when financial market regulations narrow the range of available financial instruments or products, access to finance and hence new entry and firm growth in downstream sectors can be made more difficult. Secondly, even if anti-competitive upstream regulations do not restrict market access downstream, they can still curb incentives to improve efficiency in downstream sectors or firms. When markets for intermediate inputs are imperfect, downstream firms may have to negoti-ate with suppliers and can be held up by them. Regulations that increase suppliers' market power can thus reduce incentives to improve efficiency downstream, since (temporary) profits that downstream firms may expect from such improvements will have to be shared with the suppliers. These two channels are explicitly presented in a theoretical model, drawn from [START_REF] Lopez | Essays on Product Market Regulations, Information and Communication Technologies, Research and Development and Productivity[END_REF] and also explained in [START_REF] Bourlès | Do Product Market Regulations in Upstream Sectors Curb Productivity Growth? Panel Data Evidence for OECD Countries[END_REF].

Empirical model

Our empirical analysis is based on an econometric model that directly relates country-sector productivity to regulatory burden indicators constructed on the basis of OECD indicators of non-manufacturing regulation and that interacts the effects of regulation with a gap variable of distance to the productivity technological frontier (see data section below). The model allows for persistent heterogeneity in productivity levels and growth across countries and sectors, with productivity levels and growth in follower country-sector driven by the level and growth of the productivity technology frontier. Such a model, which can be viewed as an empirical implementation of a "neo-Schumpeterian" growth framework, has been used extensively in empirical research on the determinants of productivity growth at both the firm level (e.g., Aghion et al. 2005) and industry level [START_REF] Nicoletti | Regulation, Productivity and Growth[END_REF][START_REF] Conway | Product Market Regulation and Productivity Convergence[END_REF][START_REF] Griffith | Product Market Reform and Innovation in the EU[END_REF]).

Our baseline model is precisely the following Error Correction Model (ECM):

where MFP c,s,t is the MFP level of a non-frontier country-sector pair c,s in year t; MFP F,s,t is the MFP level at the technological frontier F for sector s in year t; REG c,s,t is the regulatory burden indicator in each country/sector/year triad; is the country-sector distance from the sector frontier in year t; and where γ s , γ c,t stand for respectively sector and country-year fixed effects and ε c,s,t is a random error term. As usual we note ln(X) the natural logarithm of variable X, and ∆lnXt = lnXt -lnX t-1 the log first difference of the variable X.

Throughout our analysis, we focus on the total effects of anti-competitive upstream regulations, i.e., the expression (α 2 + α 3 gap c,s,t-1 ). Note that our estimates would be consistent with the neo-Schumpeterian view that lack of competition is more damaging for country-industry pairs that are close to frontier and that compete neck-and-neck with their global rivals only if α 2 < 0 and α 3 > 0. Note also that at the steady-state, the equilibrium distance to the technological frontier (gap c,s ) is decreasing with the difference (γ c -γ F ) between the country and the frontier technical progress effects, and increasing with the difference (REG c,s -REG F,s ) between the country and the frontier regulation levels [START_REF] Bourlès | Do Product Market Regulations in Upstream Sectors Curb Productivity Growth? Panel Data Evidence for OECD Countries[END_REF].

Data

On the basis of the OECD and EUKLEMS countrysector data bases, we have assembled an unbalanced panel of 4,629 observations for 15 countries and 20 sectors over the 1984-2007 period. Empirical research on the effects of competition on productivity has used a variety of measures of competitive pressures. We rely here on regulatory burden synthetic indicators constructed on the basis of the OECD non-manufacturing regulation elementary indicators available in the OECD international product market regulation database.2 These synthetic indicators allow taking into account the trickle down effects of competitive pressures in upstream industries on downstream industries. They have the advantage of being more or less explicitly linked to policies that affect competition, as well as that of being largely exogenous and thus minimizing potential endogeneity biases. The OECD elementary indicators of nonmanufacturing regulation are themselves based on detailed information on laws, rules and market and industry settings and cover energy (gas and electricity), transport (rail, road and air) and communication (post, fixed and cellular telecommunications), retail distribution and professional services, with country and time coverage varying across industries. In addition we also use here the indicator of restrictions to competition in financial services constructed by de [START_REF] De Serres | Regulation of Financial Systems and Economic Growth in OECD Countries: An Empirical Analysis[END_REF].

Forum

(

)

t

Empirical results

The OLS estimates for different specifications of our empirical model are presented in Bourlès et al.

(2010, Table 1). 4 The estimates are consistent with the implications of our "neo-Schumpeterian" model. MFP growth in the sector of the leader country has a positive and highly significant influence on MFP growth in the less productive sectors of other countries, indicating a sizeable rate of technological passthrough. The technology gap has also a positive and significant influence showing that countries tend to catch up in the sectors where they lag behind the leader country. Finally, as predicted, our indicator of regulatory burden is found to curb MFP growth and increasingly so, the closer MFP level is to the technological frontier. It has indeed a very significant influence due to its interaction with the MFP gap, even if it us not statistically different from zero when estimated at its mean. 5 This influence is stronger for country/sector/period triads that operate close to the technological frontier, since the interaction term coefficient is significantly positive (α 3 < 0). Interestingly, anti-competitive regulation in upstream sectors seems to have played an increasingly damaging role in MFP growth in the more recent period. Indeed, when we distinguish the two sub-periods 1985-94 and 1995-2007, the estimated average impact of the regulatory burden indicator, which is non significantly positive in the first sub-period, becomes significantly negative in the second sub-period. At the same time, the attenuating effect of the interaction of the regulatory burden and gap on MFP growth is more than halved.

The more negative impact of anti-competitive regulation on MFP growth in the recent period seems a robust finding which will need further investigation. It is likely to be related to two major sources of economic structural change during this period: globalization and the diffusion of ICT technologies. With increased integration of the world economy compe-3 In the Figure, as well as in our simulations here, best practice for the regulatory burden indicator in a given sector is constructed on the basis of the average of the three lowest values of the underlying elementary regulation indicators in the upstream sectors across countries. 4 Our estimates are quite robust to changes in data coverage and variable definitions, as documented in [START_REF] Bourlès | Do Product Market Regulations in Upstream Sectors Curb Productivity Growth? Panel Data Evidence for OECD Countries[END_REF]

Figure

tition becomes tougher for firms in downstream sectors, and ICT adoption and the corresponding reorganization of production processes become increasingly compelling for them. Thus, the erosion of returns from efficiency improvements due to their appropriation by regulated upstream sectors is likely to be more damaging for productivity incentives, and barriers to entry in upstream sectors are likely to be increasingly reflected in a drag on sector-level productivity performance. Note that such changing effects of anti-competitive regulation are different from the ones reflecting different levels of countrysector development as captured by the MFP gap.

Results of simulation exercises

To illustrate our results and their implications, we propose a simulation of the MFP gains for 24 OECD countries under the extreme assumption they would be able to reduce their regulatory burden in the year 2010 to the level of practice anti-competitive regulation observed in upstream sectors in 2007.

Precisely, the simulated MFP gains are computed under the following assumptions:

-we use the estimates over the 1995-2007 period of our econometric model specification (1) as reported in the last column of the Table of [START_REF] Bourlès | Do Product Market Regulations in Upstream Sectors Curb Productivity Growth? Panel Data Evidence for OECD Countries[END_REF]; we assume that the distance to the technological frontier, for each country-sector and the level of anti-competitive regulations in upstream sectors, are the same in 2010 as the ones known in 2007; the regulatory burden indicator is computed using the country input-output tables; -we also assume that the best practice upstream regulation indicators adopted in 2010 by the countries are defined as the average of the three lowest val-ues observed in 2007 of the anti-competitive regulation indicators in the upstream sectors across countries. 6

The Table shows the impacts of the simulated reforms on the average annual MFP growth over five years (i.e., for the period 2011-15 since a change in the regulatory burden is supposed to influence MFP growth in our econometric model with a one-year lag). These impacts are given separately for the manufacturing sectors, the non-manufacturing sectors (excluding the farm and mining sectors), the business sectors (i.e., manufacturing and non-manufacturing sectors together), and for the whole economy (where we assume that the reforms in upstream sectors have no impact on the non-business sectors).

The average annual MFP growth gains from adopting best practice upstream regulations are slightly different across countries. For the whole economy, the gains range from 0.2 of a point in Denmark to 1.7 points in Poland. These differences reflect in fact four underlying factors: (i) the differences in 2010

CESifo DICE Report 3/2010

6 Forum 6 Note that we take into account in computing such simulations of the dynamic effect of the interaction between a change in the regulatory burden and in the gap. This effect appears, however, to be rather small.

Forum

between actual anti-competitive regulation and best practices in upstream sectors, (ii) the different intensity of downstream intermediate consumption of products from the regulated upstream sectors, (iii) the initial 2010 MFP gaps in the different country-sector pairs and (iv) a composition effect due to the different sector weights in the different countries. The larger the excess regulatory burden and intermediate consumption of regulated products in the relatively more important sectors, the stronger the gains in productivity from aligning regulations in upstream sectors with best international practice; conversely, the smaller the distance to frontier the stronger the gains from deregulation.

Based on these simulation results, the 24 countries considered thus fall into three groups: Denmark, the Netherlands, Sweden and the United States with a relatively smaller impact on average MFP growth of less than of a percentage point per year; Austria, Belgium, Japan, Poland and Portugal with a very large impact of more than 1 percentage point per year; the fifteen other countries an intermediate, but still a high one, of between 0.5 and 1 percentage point per year.

Conclusion

We find robust results showing that the expected growth gains from structural reforms that consist of adopting best regulation practices in sectors that are important providers of intermediate inputs to the economy could be important. Nonetheless much more work needs to be done to check the soundness of the policy recommendations that might be drawn from our econometric and simulation results. Although they appear robust, our results should be qualified on at least two grounds. The simulated reforms we consider are of course extremely drastic: adopting the "best practices" in all upstream sectors over a short period (here one year) would be an ambitious and unrealistic task! Anti-competitive regulations on product markets tend to be positively correlated with those on labour markets, as well as negatively correlated with workers' average education and skill levels. It is thus not unlikely that our estimates do not correspond only to the impact of changes on MFP growth in upstream product market regulations, but that they may also reflect the growth impact of other changes in the economic environment, such as a lessening of labour markets regulations and increasing education and skills of the working age population.

  the sample average by country of the regulatory burden indicators in 1985, 2000 and 2007 as well as the 2000 and 2007 sector average, and corresponding best practice.3 The changes over-time reflect the evolution of non-manufacturing regulation and de-regulation in the countries covered by the sample. In spite of the convergence in policies in recent years important cross-country differences remain in 2007.

  .

		VARIABILITY OF THE "REGULATORY BURDEN"
				INDICATORS AND "BEST PRACTICE"
						0-1 scale from least to most restrictive
	0.25	A. Sample average by country in 1985, 2000 and 2007
																1985 2000 2007
	0.20
	0.15
	0.10
	0.05
	0.00
		Australia	Austria		Belgium	Canada	Germany	Denmark		Spain	Finland	France	Greece	Italy		Netherlands	Norway	Sweden	United	States	Best	practice
	0.25	B. Sample average by sector in 2000 and 2007
	0.20													2000 2007 2007 best practice
	0.15
	0.10
	0.05
	0.00
		15-16	17-19	20	21-22	23-25	26	27-28	29	30-33	34-35	36-37	40-41	45	50-52	55	60-63	64	65-67	70	71-74
	Sectors: 40-41: Electricity, gas and water supply; 50-52: Wholesale and retail trade, repairs;
	60-63: Transport and storage; 64: Post and telecomunications; 65-67: Financial intermediation;
	71-74: Renting of material and equipment and other business activity.

Table Average annual MFP growth gains from reforms implemented in 2010, for the period 2011-15 in percentage points

 Average

		Manufactur-	Non-manufac-	Business	Whole
		ing sectors	turing sectors	sectors*	economy**
		(15-37)	(40-74)	(15-74)	(01-99)
	Australia	1.04	0.66	0.72	0.51
	Austria	2.49	1.07	1.43	1.10
	Belgium	2.90	1.27	1.64	1.24
	Canada	1.75	1.00	1.16	0.81
	Switzerland	2.10	0.98	1.26	0.98
	Czech Republic	1.36	1.05	1.15	0.90
	Germany	1.90	0.78	1.11	0.85
	Denmark	0.58	0.27	0.33	0.22
	Spain	1.62	0.92	1.07	0.81
	Finland	1.45	0.59	0.85	0.63
	France	1.58	0.62	0.80	0.58
	United Kingdom	1.38	0.55	0.70	0.51
	Greece	1.63	1.09	1.19	0.84
	Hungary	1.00	0.84	0.89	0.64
	Italy	1.61	1.16	1.27	0.97
	Japan	3.29	1.58	2.02	1.62
	Korea	1.76	0.76	1.13	0.88
	Mexico	1.51	0.60	0.81	0.61
	Netherlands	0.83	0.37	0.46	0.33
	Norway	1.78	1.22	1.32	0.69
	Poland	3.86	1.82	2.35	1.73
	Portugal	1.77	1.33	1.43	1.00
	Sweden	0.63	0.31	0.39	0.29
	United States	1.32	0.52	0.66	0.49
	Industry ISIC Revision 3 in brackets.

* Excluding the farm sector and the mining and quarrying industries. This field corresponds to the sum of the two previous columns. ** The calculations for the whole economy assume that reforms to upstream sectors have no effect on the farm sector, the mining and quarrying industries and the non-business sectors.

These indicators are publicly available at www.oecd.org/eco/pmr. See[START_REF] Bourlès | Do Product Market Regulations in Upstream Sectors Curb Productivity Growth? Panel Data Evidence for OECD Countries[END_REF] for details on the construction of the regulatory burden synthetic indicators, as well as for explanations on our measures of the other variables in the econometric model: country MFP and MFP country sector gap to the sector technological frontier.

The F-test of joint equality to zero of α 1 , α 2 and α 43 and that of α 2 and α 3 are very strongly rejected.