| All publications sorted by title |
| 2012 |
| 2011 |
| 2010 |
| Systems-of-systems are formed through integration of individual complex systems, often not designed to work together. A number of factors can make this integration very challenging which often leads to catastrophic failures. In this paper, we focus on three major classes of system-of-system integration problems: managerial independence, interface incompatibility, and component-system complexity. We then present an aspect-oriented requirements description language (RDL) which uses natural language analysis capabilities to reason about dependencies across the documentation of the constituent systems of a system-of-systems. The aspect-oriented compositions in the RDL also facilitate specification of cross-document constraints and inconsistency resolution strategies, which can be used for deriving proof obligations and test cases for verification and validation of the emergent behaviour of a system-of-systems. We showcase the capabilities of our RDL through a case study of a real-world emergency response system. Our analysis shows that the querying and composition capabilities of the RDL provide valuable support for reasoning across documentation of multiple systems and specifying suitable integration constraints. |
| 2009 |
| Using a call-by-value functional language as an example, this article illustrates the use of coinductive definitions and proofs in big-step operational semantics, enabling it to describe diverging evaluations in addition to terminating evaluations. We formalize the connections between the coinductive big-step semantics and the standard small-step semantics, proving that both semantics are equivalent. We then study the use of coinductive big-step semantics in proofs of type soundness and proofs of semantic preservation for compilers. A methodological originality of this paper is that all results have been proved using the Coq proof assistant. We explain the proof-theoretic presentation of coinductive definitions and proofs offered by Coq, and show that it facilitates the discovery and the presentation of the results. |
| We present a mechanism to derivate products of Software Product Lines (SPLs) using decision models. Our approach to create SPLs is based on Model Driven Engineering principles. It uses metamodels and model transformation programs, which are sets of ordered model transformation rules, to obtain concrete software artifacts departing from an initial model. It uses also feature models to express the variability included in the SPLs. Because of the variability, to derivate product line members, we have to adapt the transformation programs according to user choices done on the feature models. The choices are gathered in configurations. Then, to derivate a product, we process a specific configuration and a decision model, which links variants, expressed as features, to model transformation rules. Thus, decision models enable the adaptation of the model transformation programs to derivate products including specific variants. |
| Cloud platforms host several independent applications on a shared resource pool with the ability to allocate computing power to applications on a per-demand basis. The use of server virtualization techniques for such platforms provide great flexibility with the ability to consolidate several virtual machines on the same physical server, to resize a virtual machine capacity and to migrate virtual machine across physical servers. A key challenge for cloud providers is to automate the management of virtual servers while taking into account both high-level QoS requirements of hosted applications and resource management costs. This paper proposes an autonomic resource manager to control the virtualized environment which decouples the provisioning of resources from the dynamic placement of virtual machines. This manager aims to optimize a global utility function which integrates both the degree of SLA fulfillment and the operating costs. We resort to a Constraint Programming approach to formulate and solve the optimization problem. Results obtained through simulations validate our approach. |
| 2008 |
| The Component Based Software Engineering (CBSE) represents an important trend in the development of software architectures. The components are the core of the software applications and the recent efforts concentrate on conceiving component models integrating important properties as for example explicit interaction protocols. Interaction protocols allow a component to publish its behavior in terms of message emission and receipt. Thus, component assemblages can be more effective than in the traditional approach where only static interfaces (input and output) are available. In this thesis, we propose a component model considering black box components integrating interaction protocols described as Symbolic Transition Systems (STSs). STSs allow the description and verification of complex protocols while dealing with the state explosion problem for example. The model also specifies the compatibility rules, the substitution and the assemblage verification algorithms and a component description language. We propose a generative approach on implementing our model in the Java programming language. The Java code is automatically generated starting from high level component descriptions assuring that the component code is conforming with its specification. |
| Model-Driven Software Product Lines (MD-SPL) are configured by using configuration models and Problem Space metamodels that capture product line scope. Products are derived by means of successive model transformations, starting from problem space models and based on the configuration models. Fine-variations of MD-SPLs correspond to characteristics that afect particular elements of models involved in the model transformations. In this paper, we present an approach to create MD-SPL including fine-variations. We configure products creating fine-feature configurations. Then, based on such configurations, we create MD-SPLs using principles of Aspects Oriented Development. Thus, our approach allows to derive products including fine-grained details of configuration. |
| 2007 |
| Les patrons de conception r\'epertorient les bonnes pratiques de la programmation par objets. Les solutions des patrons, appel\'ees motifs, apparaissent avec une densit\'e croissante dans les biblioth\`eques et cadriciels. Les effets de cette densit\'e sur la modularit\'e, l'adaptation et la r\'eutilisation des programmes sont mal connus. Or la dispersion et le m\'elange du code li\'e \`a l'impl\'ementation des motifs rendent difficile l'\'etude de ces effets. La programmation par aspects est une technique nouvelle d\'edi\'ee au traitement de ces deux sympt\^omes. En modularisant les motifs dans des aspects, nous pouvons analyser de mani\`ere plus fine les probl\`emes d'impl\'ementation et de composition des motifs li\'es \`a leur densit\'e. Cette th\`ese aborde les probl\`emes de la densit\'e, de l'impl\'ementation et de la composition des motifs avec AspectJ, une extension de Java pour les aspects. \`A partir du cas concret du cadriciel JHotDraw, nous montrons qu'une forte densit\'e est un facteur de risque sur la modularit\'e et l'adaptation d'un programme objet. Nous pr\'esentons la transformation des motifs \`a l'aide des aspects et nous d\'ecrivons les idiomes d'AspectJ supportant leur modularisation. Nous examinons la modularit\'e et la r\'eutilisation des compositions de motifs d\'efinies avec les aspects. Nous proposons la r\'esolution des interactions entre motifs \`a l'aide du langage de coupe des aspects. Enfin nous d\'eveloppons une m\'ethode de programmation avec AspectJ bas\'ee sur l'usage conjoint des classes et des aspects. Ces travaux nous permettent de conclure sur l'int\'er{\~A}ªt des aspects comme moyen d'\'etude et de traitement de la densit\'e des motifs. Ils ouvrent \'egalement des pistes pour l'am\'elioration des langages d'aspects. |
| The Krivine machine is a simple and natural implementation of the normal weak-head reduction strategy for pure l-terms. While its original description has remained unpublished, this machine has served as a basis for many variants, extensions and theoretical studies. In this paper, we present the Krivine machine and some well-known variants in a common framework. Our framework consists of a hierarchy of intermediate languages that are subsets of the l-calculus. The whole implementation process (compiler + abstract machine) is described via a sequence of transformations all of which express an implementation choice. We characterize the essence of the Krivine machine and locate it in the design space of functional language implementations. We show that, even within the particular class of Krivine machines, hundreds of variants can be designed. |
| 2006 |
| Nowadays, application developers have to deal with increasingly variable execution contexts, requiring the creation of applications able to adapt themselves autonomously to the evolutions of this context. In this paper, we show how an aspect-oriented approach enables the development of self-adaptive applications where the adaptation code is well modularized, both spatially and temporally. Concretely, we propose SAFRAN, an extension of the Fractal component model for the development of the adaptation aspect as reactive adaptation policies. These policies detect the evolutions of the execution context and adapt the base program by reconfiguring it. This way, SAFRAN allows the development of the adaptation aspect in a modular way and its dynamic weaving into applications. |
| La puissance de calcul des syst\`emes mobiles rend possible l'exploitation d'application multim\'edia. C'est souvent au d\'etriment de l'autonomie. Le cas des bornes multim\'edia est particuli\`erement int\'eressant car elles traitent des flux de fa\c{c}on continue, l'historique de traitement ainsi obtenu peut {\~A}ªtre utilis\'e pour alimenter un algorithme de d\'ecision de gestion de l'\'energie du syst\`eme et augmenter l'autonomie. Cette approche permet de maximiser l'utilisation de la ressource \'energ\'etique fournie par des panneaux solairee ou des batteries. |
| Video kiosks increasingly contain powerful PC-like embedded processors, allowing them to display video at a high level of quality. Such video display, however, entails significant energy consumption. This paper presents an approach to reducing energy consumption by adapting the CPU clock frequency. In contrast to previous approaches, we exploit the specific behavior of a video kiosk. Because a kiosk plays the same set of movies over and over, we choose a CPU frequency for a given frame based on the computational requirements of the frame that were observed on earlier iterations. We have implemented our approach in the legacy video player MPlayer. On a PC like those that can be found in kiosks, we observe increases in battery lifetime of up to 2 times as compared to running at the maximum CPU frequency on a set of high resolution divx movies. |
| Distribution-related concerns, such as data replication, often crosscut the business code of a distributed application. Currently such crosscutting concerns are frequently realized on top of distributed frameworks, such as EJBs, and initial AO support for the modularization of such crosscutting concerns, \eg JBoss AOP and Spring AOP, has been proposed. Based on an investigation of the implementation of replicated caches using JBoss Cache, we motivate that crosscutting concerns of distributed applications benefit from an aspect language for explicit distributed programming. We propose \dhamaca, a new aspect language with explicit distributed programming mechanisms, which provides three contributions. First, remote pointcut constructors which are more general than those of previous related approaches, in particular, supporting remote sequences. Second, a notion of distributed advice with support for asynchronous and synchronous execution. Third, a notion of distributed aspects including models for the deployment, instantiation and state sharing of aspects. We show several concrete examples how \dhamaca can be used to modularly implement and extend replicated cache implementations. Finally, we present a prototype implementation of \dhamaca, which we have realized by extending JAsCo, a system providing dynamic aspects for Java. |
| 2005 |
| Les contextes toujours plus vari\'es et dynamiques dans lesquels les logiciels actuels s'ex\'ecutent leurs imposent de s'adapter de fa\c{c}on autonome \`a ces changements. L'objectif de cette th\`ese est de faciliter le d\'eveloppement de telles applications adaptatives, en consid\'erant l'adaptation comme un aspect qui doit {\~A}ªtre d\'evelopp\'e s\'epar\'ement du reste de l'application afin de pouvoir y {\~A}ªtre int\'egr\'e et modifi\'e dynamiquement. Pour cela nous proposons SAFRAN, une extension du mod\`ele de composants Fractal permettant d'associer dynamiquement des politiques d'adaptation aux composants d'une application. Ces politiques sont programm\'ees dans un langage d\'edi\'e sous la forme de r\`egles r\'eactives. Leur ex\'ecution repose d'une part sur WildCAT, un syst\`eme permettant de d\'etecter les volutions du contexte d'ex\'ecution (quand adapter ?), et d'autre part sur FScript, un langage d\'edi\'e pour la reconfiguration dynamique consistante de composants Fractal (comment adapter ?). |
| Cette th\`ese aborde le probl\`eme de la multiplication des machines interm\'ediaires sur Internet. L'\'etude des performances de ce dernier motive l'existence de ces derni\`eres afin de r\'esoudre les probl\`emes de latence. C'est la multiplication des services disponibles sur Internet qui appelle le pullement des machines interm\'ediaires : chaque fournisseur de service cherche \`a d\'eployer, ou faire d\'eployer, des machines diminuant la latence des services qu'il fournit. Chaque service sp\'ecifique appelle une strat\'egie de r\'eplication particuli\`ere nourrissant \`a son tour l'explosion du nombre de machines interm\'ediaires d\'eploy\'ees aux fronti\`eres des r\'eseaux constituant Internet. Afin de rem\'edier \`a cette explosion, notre contribution se r\'esume \`a la construction d'un cache Web adaptable. Nous proposons d'utiliser la programmation par aspect afin de faire d'un cache Web patrimoniel : squid un cache Web ouvert. Les aspects tiss\'es \`a la vol\'ee permettent de construire l'interface entre le cache et l'adaptation. L'avantage de cette approche est de retarder le moment de la sp\'ecification de l'interface d'adaptation au moment seulement o{\~A}¹ les programmeurs sont capables de la d\'efinir, c'est-\`a-dire au moment o{\~A}¹ l'adaptation est programm\'ee. En l'absence de langage \`a aspects susceptible de servir de support \`a notre d\'emarche, nous avons con\c{c}u notre propre langage d'aspects. D'apr\`es les \'evaluations que nous avons pu conduire, les performances d'Arachne - notre syst\`eme \`a aspects - permettent de faire de squid un cache Web ouvert. Ainsi, le d\'eploiement de notre proposition est une piste prometteuse pour mettre un terme au pullulement des machines interm\'ediaires sur Internet. En acc\'el\'erant le d\'eploiement des adaptations des strat\'egies de r\'eplication existantes r\'eduisant la latence pour les nouveaux sevices, notre proposition augmente les performances d'Internet tout en mutualisant les investissements n\'ecessaires \`a son infrastructure. |
| Les d\'eveloppeurs d'application sont aujourd'hui confront\'es \`a des contextes d'ex\'ecution de plus en plus variables, qui n\'ecessitent la cr\'eation d'applications capables de s'adapter de fa\c{c}on autonome aux \'evolutions de ces contextes. Dans cet article, nous montrons qu'une approche par aspects permet de construire des applications adaptatives dans lesquelles le code d'adaptation est modularis\'e aussi bien sur le plan spatial que temporel. Concr\`etement, nous proposons SAFRAN, une extension du mod\`ele de composants Fractal permettant le d\'eveloppement de l'aspect d'adaptation sous la forme de politiques r\'eactives. Celles-ci d\'etectent les \'evolutions du contexte d'ex\'ecution et adaptent le programme de base en le reconfigurant. SAFRAN permet ainsi de d\'evelopper l'aspect d'adaptation de fa\c{c}on modulaire et de le tisser dynamiquement dans les applications. |
| We present WildCAT, an extensible Java framework to ease the creation of context-aware applications. WildCAT provides a simple yet powerful dynamic model to represent an application's execution context. The context information can be accessed by application programmers through two complimentary interfaces: synchronous requests (pull mode) and asynchronous notifications (push mode). Internally, WildCAT is designed to support different kinds of extensions, from the simple configuration of the default generic implementation to completely new implementations tailored to specific needs. A given application can mix different implementations for different aspects of its context while only depending on WildCAT simple and unified API. |
| Component-Based Software Engineering (CBSE) has now emerged as a discipline for system development. Important issues in CBSE such as composition incompatibility detection and (dynamic) adaptation can only be addressed with the help of formal component models with Behavioural Interface Description Languages (BIDLs) and explicit protocols. The issue is then to fill the gap between such high-level models and implementation. This paper suggests to do so by relying on Symbolic Transition Systems (STSs). It describes a component model with explicit symbolic protocols based on STSs, and its implementation in Java. This implementation is based on controllers that encapsulate protocols and channels devoted to (possibly remote) communications between components. |
| Behavioral specifications which are integrated into component interfaces are an important means for the correct construction of component-based systems. Currently, such specifications are typically limited to finite-state protocols because more expressive notions of protocol do not support reasonable basic composition properties, such as compatibility and substitutability. In this paper, we present first results of the integration into component interfaces of a notion of non-regular protocols based on {``}non-regular process types{''} introduced by Puntigam. More concretely, we present three contributions: (i) a motivation of the usefulness of non-regular protocols in the context of peer-to-peer applications, (ii) a language for non-regular protocols and an outline of a suitable formal definition, (iii) a discussion of basic composition properties and an analysis of how to adequately integrate protocol-modifying operators in the model. |
| 2004 |
| This paper considers the use of a state-of-the-art, general-purpose, component-programming language, specifically ArchJava, to implement software product lines. Component-programming languages provide a more straightforward mapping between components as assets and components as implementation artifacts. However, guaranteeing that the implementation conforms to the architecture raises new issues with respect to dynamic configuration. We show how this can be solved in ArchJava by making the components auto-configurable, which corresponds to replacing components by component generators. Such a scheme can be implemented in various ways, in particular with a two-stage generator. This solution goes beyond the initial technical ArchJava issue and complements the standard static generative approach to software product line implementation. |
| Dans ce document nous abordons les diff\'erents aspects li\'es \'a la gestion de l'\'energie au sein du processeur. Bossa offre les abstractions n\'ecessaires \'a la gestion de la ressource processeur, il utilise un langage d\'edi\'e et manipule une ressource de premi\`ere classe: le processeur. La ressource \'energ\'etique est une ressource de premi\`ere classe et certaines strat\'egies de gestion de l'\'energie manipulent la ressource processeur. Bossa n'a pas \'et\'e con\c{c}u au d\'epart pour prendre en compte la probl\'ematique de la gestion de l'\'energie. Il est int\'eressant d'\'etudier si le \"framework\" Bossa peut \^etre utilis\'e pour la gestion de l'\'energie du processeur en l'\'etendant facilement. Nous pr\'esentons ce qu'est la probl\'ematique de la gestion de l'\'energie, les objectifs de cette gestion et les strat\'egies misent en \oe uvre pour r\'ealiser ces objectifs. Avec Bossa nous proposons de r\'ealiser des strat\'egies de gestion de l'\'energie ais\'ement en utilisant les outils du "framework". Pour essayer de r\'epondre \`a ces questions il est peut {\~A}ªtre int\'eressant d'\'etudier les syst\`emes qui tentent de prendre en compte \`a la fois la ressource processeur et la ressource \'energ\'etique. Nous pr\'esentons des solutions pour \'etendre Bossa afin d'impl\'ementer ces strat\'egies de gestion de l'\'energie. |
| 2003 |
| Les patrons de conception sont importants en g\'enie logiciel \`a objets car ils contribuent \`a la qualit\'e des programmes. Ils proposent des solutions \'el\'egantes \`a des probl\`emes r\'ecurrents de conception, des motifs utilis\'es pendant l'impl\'ementation. \`A l'usage, ces motifs de conception sont diss\'emin\'es dans le code source et ne sont plus explicites lors de la maintenance ; pourtant, ils aideraient \`a comprendre l'impl\'ementation et la conception des programmes, assurant leur qualit\'e. Ce m\'emoire propose des mod\`eles et des algorithmes pour garantir la tra\c{c}abilit\'e des motifs de conception entre les phases d'impl\'ementation et de r\'etroconception des programmes par l'identification semi-automatique des micro-architectures similaires \`a ces motifs dans le code source. La m\'etamod\'elisation est utilis\'ee pour d\'ecrire les motifs de conception et les programmes Java. Elle am\`ene \`a expliciter certaines relations interclasses (association, agr\'egation et composition) offertes par les langages de conception comme UML et \`a pr\'eciser leurs propri\'et\'es (dur\'ee de vie, exclusivit\'e, multiplicit\'e et site d'invocation) pour les identifier avec des algorithmes d'analyses statiques et dynamiques. Elle conduit aussi \`a traduire les motifs en syst\`emes de contraintes et \`a identifier les micro-architectures similaires, formes compl\`etes et approch\'ees, par la r\'esolution de probl\`emes de satisfaction de contraintes. La programmation par contraintes avec explications permet de guider la r\'esolution et d'expliquer les micro-architectures identifi\'ees. La suite d'outils Ptidej impl\'emente les mod\`eles et les algorithmes propos\'es. Elle est int\'egr\'ee \`a l'environnement Eclipse de d\'eveloppement en Java. Elle inclut le m\'etamod\`ele PADL, d\'eriv\'e du m\'etamod\`ele PDL ; des outils d'analyses statiques et dynamiques, Introspector et Caffeine ; et un solveur de contraintes, PtidejSolver, d\'eriv\'e du solveur de contraintes avec explications de r\'ef\'erence PaLM. |
| Given today's fast pace of technological evolutions and diversity of computing platforms, building applications which can work in such a wide range of systems is becoming more and more challenging. To deal with this situation, applications must be \emph{self-adaptive}, that is adapt themselves to their environment and its evolutions. The goal of our works is to enable systematic development of self-adaptive component-based applications using the Separation of Concerns principle: we consider \emph{adaptation to a specific execution context and its evolutions} as a concern which should be treated separately from the rest of an application. In this paper, we first present the general approach we propose and the corresponding development framework and tools we are developing to support it. Then, in order to validate this approach, we show how a small component-based application can be made self-adaptive using our approach. |
| Component-based programming promises to ease the construction of large-scale applications. The construction of applications using components relies on the notion of interfaces. However, the notion of interfaces provided by current component models is restricted: In particular, it does not include behavioral information to define the protocols of the components: Sequences of service requests. The lack of behavioral information limits our trust in components: Security, reuse, and quality relate directly on this missing information. In this paper, we consider the problem of verifying if a component implementation respects the protocol specified during its design. First, we define a notion of coherence between protocols and an algorithm to verify the coherence between two protocols. Then, we describe an algorithm to extract the protocol of a component from its source code. Finally, we present a tool that enables the static verification and enforcement of the notion of coherence. |
| Asynchronous communications are prominent in distributed and mobile systems. Often concurrent systems consider an abstract point of view with synchronous communications. However it seems more realistic and finer to consider asynchronous communicating systems, since it provides a more primitive communication protocol and maximize the concurrency. Several languages and models have been defined using this communication mode: agent, actor, mobile computation, and so on. Here we reconsider a previous component model with full data types and synchronous communications with an asynchronous flavour. The dynamic behaviour of a component is represented as a structured symbolic transition system with mailboxes. We also present an algorithm devoted to an analysis of the dynamic behaviour of the system. This algorithm decides if the system has bound mailboxes and computes the reachable mailbox contents of the system. The component model and the algorithm are illustrated on a flight system reservation. |
| Given the high proportion of HTTP traffic in the Internet, Web caches are crucial to reduce user access time, network latency, and bandwidth consumption. Prefetching in a Web cache can further enhance these benefits. Nevertheless, to achieve the best performance, the prefetching policy must match user and Web server characteristics. This implies that new prefetching policies must be loaded dynamically as needs change. Most Web caches are large C programs, and thus adding a single prefetching policy to an existing Web cache is a daunting task. Providing multiple policies is even more complex. The essential problem is that prefetching concerns crosscut the cache structure. Aspect-oriented programming is a natural technique to address this issue. Nevertheless, existing approaches do not provide dynamic weaving of aspects targeted toward C applications. In this paper, we present $\mu$Dyner, which addresses these needs. $\mu$Dyner also provides lower overhead for aspect invocation than other dynamic approaches, thus meeting the performance needs of Web caches. |
| Behavioral reflection is a powerful approach for adapting the behavior of running applications. In this paper we present and motivate partial behavioral reflection, an approach to more efficient and flexible behavioral reflection. We expose the spatial and temporal dimensions of such reflection, and propose a model of partial behavioral reflection based on the notion of hooksets. In the context of Java, we describe a reflective architecture offering appropriate interfaces for static and dynamic configuration of partial behavioral reflection at various levels, as well as Reflex, an open reflective extension for Java implementing this architecture. Reflex is the first extension that fully supports partial behavioral reflection in a portable manner, and that seamlessly integrates load-time and runtime behavioral reflection. The paper shows preliminary benchmarks and examples supporting the approach. The examples, dealing with the observer pattern and asynchronous communication via transparent futures, also show the interest of partial behavioral reflection as a tool for open dynamic Aspect-Oriented Programming. |
| Automating software evolution requires both identifying precisely the affected program points and selecting the appropriate modification at each point. This task is particularly complicated when considering large pieces of software, even when the modifications appear to be systematic. We illustrate this situation in the context of evolving the Linux kernel to support Bossa, an event-based framework for process-scheduler development. To support Bossa, events must be added at points scattered throughout the kernel. In each case, the choice of event depends on properties of one or a sequence of instructions. To describe precisely the choice of event, we propose to guide the event insertion by using a set of rules, amounting to an aspect, that describes the control-flow contexts in which each event should be generated. In this paper, we present our approach and describe the set of rules that allow proper event insertion. These rules use temporal logic to describe sequences of instructions that require events to be inserted. We also give an overview of an implementation that we have developed to automatically perform this evolution. |
| 2002 |
| There is a continuous demand for new scheduling policies to address specific requirements of modern OSes. However, the implementation of such policies within an existing OS kernel raises many problems, mainly because optimizations within schedulers hinder code maintenance and implementation of existing schedulers is spread over the kernel. In this paper we motivate that schedulers form an aspect within OS kernels. We show how the DSL of the Bossa system for the definition of scheduling policies and its runtime support can be integrated with a framework for Aspect-Oriented Programming, Event-based AOP. Finally, we discuss the generalization of AOP-based techniques to other OS kernel modules. |
| In this paper, we consider a direct, source-to-source, specialization of Java programs. In this setting, specialization does not boil down to partially evaluating functions (here called methods) any longer. Indeed, specialized methods have also to be encapsulated into residual classes. We show that inheritance offers new specialization opportunities but that these opportunities are not so easy to benefit from because of some deep incompatibilities between specialization as partial evaluation and specialization as inheritance in standard object-oriented languages. |
| In order to build programs able to adapt themselves to changing execution conditions, we propose a Separation of Concerns approach distinguishing functional and non-functional concerns. These two kinds of concerns are composed together, at run-time, by a weaver which is aware of the execution conditions so that it can adapt its weaving to their evolution. |
| Aspect-Oriented Programming (AOP) promises separation of concerns at the implementation level. However, aspects are not always orthogonal and aspect interaction is an important problem. Currently there is almost no support for the detection and resolution of such interactions. The programmer is responsible for identifying interactions between conflicting aspects and implementing conflict resolution code. In this paper, we propose a solution to this problem based on a generic framework for AOP. The contributions are threefold: we present a formal and expressive crosscut language, two static conflict analyses and some linguistic support for conflict resolution. |
| Using conflict sets (or nogoods) and explanations within constraint programming has been proved very effective. However, most constraint solvers do not provide this feature. This statement could have been made for many other improvements. Indeed, one of the main reasons of that fact is that many improvements in constraint programming are intrusive: their integration requires a general modification of the solvers' implementation and/or architecture. The core part of constraint solvers is often quite simple, however, it represents only a small part of the implementation. The main part of the code is devoted to specific constraint handling, global constraints, search techniques, API, etc. Modifying this code requires a real development effort that may become overly costly. Constraint solvers need non intrusive approaches. Actually, solvers should not be modified at all and only a general information about implementation should be needed to integrate improvements. In this paper, we present a technique used in software engineering to reach that aim: aspect oriented programming. As an example, the non intrusive integration of conflict set generation and use is presented and some insights of what could be done are provided. |
| Constraint solvers are useful tools that provide solutions to very complex problems. These infrastructure software rely on simple mechanisms, however their actual implementation can be quite complex. A good knowledge of their inner mechanisms is required to introduce enhancements which crosscut basic algorithms and structures. In this paper, we advocate non-intrusive constraint solver enhancements. First, a minimal solver is introduced. Second, different enhancements are implemented with the help of aspect oriented programming. |
| Software maintenance is a costly and tedious phase in the software development process Woods98-ConstraintRecovery. During this phase, a maintainer needs both to understand and to modify a program source code. Therefore, the maintainer must obtain a representation of the program that accurately reflects its structure and its behavior. Then, the maintainer must find those places in the program that require modification. Finally, the maintainer must perform changes that improve the program behavior and do not introduce further defects. In our research work, we focus on the maintainer's first and second tasks: The obtention of an accurate representation of the program structure and behavior, and the detection of places to improve. We propose a set of software engineering tools, for the structural and dynamic representation of Java program, and for the (semi-) automated detection of design patterns and design defects. Design patterns and design defects are related: A group of classes which micro-architecture is similar (but not identical) to a design pattern corresponds to a possible design defect. |
| To be in harmony with continuous variations of the execution environment such as fluctuating network bandwidth, decreasing battery power, and so on, new approaches are required for component-based middleware to make them adaptable with regard to these changes. The aim of the work presented in this paper is to enhance the EJB architecture by allowing applications to be aware of, and adapt to, variations in the execution context. We propose to dynamically adapt the association between EJB components and middleware services when necessary. Thus, EJB applications have the advantage to be dynamically adaptive according to changes related to their execution context. |
| Aspect-Oriented Programming (AOP) promises separation of concerns at the implementation level. However, aspects are not always orthogonal and aspect interaction is an important problem. Currently there is almost no support for the detection and resolution of such interactions. The programmer is responsible for identifying interactions between conflicting aspects and implementing conflict resolution code. In this paper, we propose a solution to this problem based on a generic framework for AOP. The contributions are threefold: we present a formal and expressive crosscut language, two static conflict analyses and some linguistic support for conflict resolution. |
| Component-based programming promises to facilitate the construction of large-scale applications, which is supported by the important concept of interfaces. In most current component models, interfaces essentially declare types and sets of services that a component implements. They are not expressive enough to formulate many properties important for component collaboration. In this paper we consider an important class of such properties, sequencing constraints, which components must obey when calling one another services. We consider the integration into interfaces of sequencing properties by means of protocols formalized in terms of finite-state machines. The paper presents three contributions. First, a set of protocol composition operators and a discussion of correctness properties of such operators useful for component assembly. Second, we provide a first step toward the integration of additional state information into protocols. Finally, we show how JavaBeans can benefit from the techniques we present. |
| A discontinuity exists between modeling languages and object-oriented programming languages. This discontinuity is a consequence of ambiguous notions in modeling languages and lack of corresponding notions in object-oriented programming languages. It hinders the transition between a software design and its implementation, and vice versa. Thus, it hampers the implementation and the maintenance processes. This discontinuity is particularly acute for binary class relationships, which describe, at the design level, notions such as association, aggregation, and composition. From the current state of the art, we propose synthetic definitions for the binary class relationships at the design level and corresponding definitions at the implementation level. We express the latter definitions in terms of common properties. We present algorithms to synthesize code for these properties and to detect these properties in code. These algorithms allow us to generate and to detect binary class relationships. We verify the detection algorithms on several well-known frameworks. The definitions and algorithms bring continuity between modeling languages and object-oriented programming languages. |
| To understand the behavior of a program, a maintainer reads some code, asks a question about this code, conjectures an answer, and searches the code and the documentation for confirmation of her conjecture. However, the confirmation of the conjecture can be error-prone and time-consuming because the maintainer only has static information at her disposal. She would benefit from dynamic information. In this paper, we present Caffeine, an assistant that helps the maintainer in checking her conjecture about the behavior of a Java program. Our assistant is a dynamic analysis tool that uses the Java platform debug architecture to generate a trace, ie an execution history, and a Prolog engine to perform queries over the trace. We present a usage scenario based on the n-queens problem, and two examples based on the Singleton design pattern and on the composition relationship. |
| 2001 |
| Computational reflection is gaining interest in practical applications as witnessed by the use of reflection in the Java programming environment and recent work on reflective middleware. Reflective systems offer many different reflection programming interfaces, the so-called Meta-Object Protocols (MOPs). Their design is subject to a number of constraints relating to, among others, expressive power, efficiency and security properties. Since these constraints are different from one application to another, we should be able to easily provide specially-tailored MOPs. In this paper, we present a generic reification technique based on program transformation. It enables the selective reification of arbitrary parts of object-oriented metacircular interpreters. The program transformation can be applied to different interpreter definitions. Each resulting reflective implementation provides a different MOP directly derived from the original interpreter definition. |
| Design patterns ease designing, understanding, and re-engineering software. Achieving a well-designed piece of software require a deep understanding and a good practice of design patterns. Understanding existing software relies on the ability to identify architectural forms resulting of the implementation of design patterns. Maintaining software involves spotting places that can be improved using better design decisions, like those advocated by design patterns. Nevertheless, there is a lack of tools automatizing the use of design patterns to achieve well-designed pieces of software, to identify recurrent architectural forms, and to maintain software. In this paper, we present a set of tools and techniques to help OO software practitioners design, understand, and re-engineer a piece of software, using design-patterns. A first prototype tools, Patterns-Box, provides assistance in designing the architecture of a new piece of softwaren, while a second prototype tool, Ptidej, identifies design patterns used in an existing one. These tools, in combination, support maintenance by higlighting and applying corrections based on widely-accepted design patterns solutions. |
| Design patterns are of major interest to increase software quality and abstraction level. However, design patterns are difficult to choose, to apply, and to recover. We propose a set of tools to use design patterns in a round-trip fashion. We a meta-model to describe design patterns. This meta-model is specifically oriented towards design patterns instantiation and detection. We develop a source-to-source transformation engine to modify the source code to comply with design patterns descriptions. Meanwhile, we use an explanation-based constraint solver to detect design patterns in source code from their descriptions. With these tools, we hope to offer a mean to apply and to recover design patterns without overhead for the developers. |
| Design Patterns have been quickly adopted by the object-oriented community, in particular since the publication of "Design Patterns: Elements of Reusable Object-Oriented Software". They offer elegant and reusable solutions to recurring problems of design. Their use increases productivity and development quality. However, these solutions, at the boundary of programming languages and design models, suffer from a lack of formalism. For this reason, their application remains empirical and manually performed. This position paper presents how a meta-model can be used to obtain a representation of design patterns and how this representation allows both automatic code generation and design patterns detection. |
| Crosscutting, i.e. relating different program points is one of the key notions of Aspect-Oriented Programming. In this report, we consider a general and operational model for crosscutting based on execution monitors. A domain-specific language for the definition of crosscuts constitutes the core of the report. The semantics of this language is formally defined by means of parser operators matching event patterns in execution traces. We define an operational semantics of the matching process by means of rules relating the operators. The use of the language is exemplified by several sophisticated crosscut definitions. We sketch a prototype implementation in Java which has been systematically derived from the language definition. |
| Les patrons de conception décrivent des micro-architectures qui résolvent des problèmes architecturaux récurrents. Il est important d'identifier ces micro-architectures lors de la maintenance des programmes orientés objets. Mais ces micro-architectures apparaissent souvent sous des formes dégradées dans le code source. Nous présentons une application de la programmation par contraintes avec explications pour l'identification de ces micro-architectures dégradées. |
| Design-patterns describe micro-architectures that solve recurrent architectural problems in objec-oriented programming languages. It is important to identify these micro-architectures during the maintenant of objec-oriented programs. But, these micro-architectures often appear distorted in the source code. We present an application of explanation-based constraint programming for identifying these distorted micro-architectures. |
| The OCM (Object, Components, Model) group of the computer science department at Ecole des Mines de Nantes is interested in Aspect-Oriented Programming (AOP). This report is a collection of three short articles presenting work in progress at our lab. We focus on two approaches: AOP from a monitoring perspective (articles 1 and 2) and different approaches to achieve AOP weaving (article 3). |
| Cette étude a permis de concevoir et développer une infrastructure pour le middleware adaptable, capable d'adapter de façon la plus transparente possible (pour le programmeur d'application) les applications à des conditions changeantes d'exécution, aussi bien statiquement (configuration au déploiement) que dynamiquement (reconfiguration automatique à l'exécution). La solution proposée est basée sur un protocole à métaobjets de type run-time permettant de séparer le code fonctionnel des services non-fonctionnels des applications et de modifier dynamiquement leurs associations. L'infrastructure développée met en oeuvre des politiques d'adaptation crites en {XML} (certaines définies par le programmeur, d'autres de type système indépendantes des applications) pour décider quand et comment effectuer ces reconfigurations à la volée. |
| Crosscutting, i.e. relating different program points is one of the key notions of Aspect-Oriented Programming. In this report, we consider a general and operational model for crosscutting based on execution monitors. A domain-specific language for the definition of crosscuts constitutes the core of the report. The semantics of this language is formally defined by means of parser operators matching event patterns in execution traces. We define an operational semantics of the matching process by means of rules relating the operators and illustrate how to use these rules to formally prove optimization properties. The use of the language is exemplified by several sophisticated crosscut definitions. We present a prototype implementation in Java which has been systematically derived from the language definition. |
| 2000 |
| Cet article constitue un survol du domaine de la programmation par objets (PPO). Après un rappel des caractéristiques du modèle objet et un rapide historique, il présente les principaux résultats obtenus depuis 1965, principalement en matière de création de nouveaux langages objets et d'architectures logicielles. Il esquisse finalement les directions de recherche les plus prometteuses et les plus stratégiques. |
| In order to exploit specialization opportunities that exist in programs written by researchers outside of the programming language community, a partial evaluator needs to effectively treat existing realistic applications. Our empirical studies have demonstrated that real-sized applications extensively use non-liftable values such as pointers and data structures. Therefore, it is essential that the binding-time analysis accurately treats non-liftable values. To achieve this accuracy, we introduce the notion of use sensitivity, and present a use-sensitive binding-time analysis for C programs which is obtained by a forward analysis followed by a backward analysis. This analysis has been implemented and integrated into our partial evaluator for C, called Tempo. |
| We present in this paper our current investigations dealing with reflection for code mobility. Our study is about reifying different concerns of mobile agent systems in order to ease their customization. Reflection enables the construction of open mobile agent systems and helps separation of concerns. Following previous ideas introduced for reflective middleware, we consider run-time adaptability of agent mechanisms. The main idea is that network introspection can be used to dynamically choose the best execution policy. Based on some well-known design patterns, our approach enables this run-time adaptability of the infrastructure of mobile agent systems. |
| Premier livrable de la CTI FT R\&D sur l'application de la programmation par aspects au code mobile Java. |
| 1999 |
| Un langage à objets est dit réflexif s'il réifie les entités qui forment les programmes (les méthodes, les classes,...) et celles qui sont responsables de leur exécution (la pile d'exécution, la mémoire,...). La représentation de ces entités sous forme d'objets permet de les manipuler et de les spécialiser via des protocoles qualifiés de protocoles de méta-objets ou MOPs. Dans les langages à classes réflexifs, les classes sont réifiées et sont donc instances d'autres classes : les métaclasses. Ces métaclasses constituent un outil privilégié pour définir et expliciter les propriétés de classe. Pour étudier cet outil, nous proposons un nouveau MOP pour Smalltalk, qui décrit explicitement les mécanismes d'envoi de messages, de construction des instances et d'accès à leurs structures. Cependant, l'utilisation de ce MOP se heurte à deux problèmes : celui de la composition des métaclasses, dès qu'il s'agit d'attribuer plusieurs propriétés à une même classe, et celui de la compatibilité lorsque le couplage entre les liens d'héritage et d'instanciation n'est pas pris en compte à la définition de nouvelles (méta)classes. Nous proposons une solution - basée sur l'héritage - à chacun de ces problèmes. Une application des métaclasses est leur utilisation comme support à la mise en oeuvre de la programmation par aspects (AOP). L'idée maîtresse de ce nouveau paradigme de programmation consiste à introduire une dimension de réutilisation qui complète celle de l'approche objet. Pour ce faire, les logiciels sont découpés en modules orthogonaux, chacun d'eux décrivant un aspect particulier (distribution, concurrence,...). Nous proposons de représenter ces aspects à l'aide des métaclasses. Cette approche présente l'avantage de simplifier le problème de composition d'aspects et de le ramener à un problème connu - celui de la composition de métaclasses - pour lequel nous disposons d'une solution basée sur l'héritage. |
| Avec l'émergence des patterns de conception, plusieurs outils ont été proposés pour supporter une utilisation et une application automatisée des patterns dans des cas concrets. Cet article présente une revue d'un ensemble représentatif de ces outils, détaillant, en plus de leur objectif et de leurs fonctionnalités, les types de représentation adoptés pour les patterns et les choix liés à leur implémentation. |
| La programmation par objets encourage la réutilisation notamment grâce à l'encapsulation et à l'héritage. Elle offre ainsi les possibilités d'interchanger des objets ayant la même interface ou d'adapter des objets existants à de nouveaux besoins. Sans remettre en cause les principes qui ont fait le succès de la programmation par objets, la programmation par aspects propose une nouvelle voie complémentaire en matière de réutilisation. Elle consiste à découper les applications en modules traitant chacun un aspect de l'application. Ces différents aspects doivent être composés entre eux pour produire l'application. La représentation des aspects et la manière de les composer sont des questions ouvertes. Nous proposons d'y répondre dans un cadre de programmation réflexive, basé sur les métaclasses. L'aspect correspondant aux fonctionnalités de l'application est alors décrit à l'aide des classes. Les autres aspects qui représentent la manière d'exécuter l'application (e.g. concurrence, distribution, gestion de la mémoire, ...) sont, quant à eux, décrits à l'aide de métaclasses. Cette représentation présente l'avantage de ramener le problème de composition d'aspects en un problème connu qui est celui de la composition de (méta)classes et qui, de plus, est indépendant des aspects manipulés et de leur nombre. |
| Aujourd'hui, l'architecture CORBA constitue la solution industrielle la plus prometteuse pour réaliser l'interopérabilité entre des composants logiciels répartis hétérogènes. Paradoxalement, alors que le projet CORBA cherche à fédérer des mécanismes de distribution au sein d'une même architecture, son modèle est peu flexible et parait inadapté aux futures évolutions. Dans cet article, nous présentons OpenCorba, un ORB réflexif, capable d'adapter dynamiquement les stratégies de représentation et d'exécution du bus logiciel. Nous exposons tout d'abord les fondements réflexifs sous-jacents à la réalisation de OpenCorba. Nous montrons comment le concept de métaclasse permet l'isolement de propriétés spécifiques liées aux classes améliorant ainsi leur réutilisabilité. Puis, pour répondre aux problèmes des systèmes devant évoluer à l'exécution sans interrompre leur fonctionnement, nous introduisons un protocole de changement dynamique de métaclasse. S'appuyant sur ce cadre réflexif, OpenCorba permet de rendre plus "malléable" les caractéristiques internes du bus logiciel dans le but d'intervenir sur son modèle d'exécution répartie (e.g. invocation, contrôle de type IDL, gestion d'erreurs). OpenCorba favorise ainsi la construction d'architectures réparties réutilisables et adaptables, i.e. ouvertes. |
| Today, CORBA architecture brings the major industrial solution forachieving the interoperability between distributed software components in heterogeneous environments. While the CORBA project attempts to federate distributed mechanisms within a unique architecture, its internal model isnot very flexible and seems not to be suitable for future evolutions. In this paper, we present OpenCorba, a reflective open broker, enabling users to adapt dynamically the representation and the execution policies of the software bus. We first expose the reflective foundations underlying the implementation ofOpenCorba: i) metaclasses which provide a better separation of concerns in order to improve the class reuse; ii) a protocol which enables the dynamicchanging of metaclass in order to allow run-time adaptation of sstems. Based on this reflective environment, OpenCorba enables the adaptability of the internal characteristics of the broker in order to change its run-time behavior (e.g. remote invocation, IDL type checking, IR error handling). OpenCorba gives a clear example of the benefits of reflective middleware. |
| Since Smith seminal work, there have been numerous reflective language definition and implementation proposals. These proposals, initially restricted to functional languages, have been quickly extended to object-oriented languages. Unfortunately, reflective object-oriented language definitions remained mostly ad hoc. In this paper, we present a generic reification technique which enables the selective reification of arbitrary parts of object-oriented language interpreters. Our program transformation can be applied to different interpreter definitions. Each resulting reflective implementation provides a different meta-object protocol based on the original interpreter definition. This technique paves the way to a systematic study of reflective object-oriented language implementations. |
| 1998 |
| Aujourd'hui, la technologie objet s'impose dans le monde industriel comme la meilleure solution pour répondre aux problèmes de l'intégration et de la réutilisation des composants logiciels distribués. En normalisant des spécifications pour la portabilité et l'interopérabilité des composants objets, le bus logiciel CORBA (Common Object Request Broker Architecture) constitue une première approche pour aborder le problème de la construction d'applications distribuées à objets. Par ailleurs, les concepts de la réflexion permettent de réaliser des systèmes ouverts en rendant adaptables les différentes caractéristiques d'un programme. Ainsi, dans le contexte des environnements répartis, les langages réflexifs offrent un modèle dynamique d'exécution permettant l'introspection et la modification des stratégies et des mécanismes de distribution. L'objectif de cette thèse est d'explorer l'apport des techniques de réflexion dans le cadre des architectures distribuées et plus particulièrement autour de CORBA. Nous mettons notamment l'accent sur deux propriétés indispensables pour la construction d'applications réparties : la séparation des aspects et l'adaptabilité dynamique. Nous présentons OpenCorba, un système ouvert, basé sur un nouveau protocole à métaobjets Smalltalk. Il réifie différents aspects du bus CORBA afin de rendre plus malléable la « boîte noire » de l'ORB (Object Request Broker, i.e. le bus). OpenCorba favorise la séparation des caractéristiques internes du bus pour mieux les organiser, les rendre modulaires et donc interchangeables (séparation des aspects). OpenCorba permet ainsi d'intervenir sur le modèle d'exécution répartie de l'ORB, pour changer dynamiquement les stratégies de représentation et d'exécution (adaptabilité dynamique). OpenCorba est le premier ORB réflexif apportant la flexibilité nécessaire aux environnements distribués. |
| La conception des bases de données à objets est une activité complexe, qui fait appel à des connaissances variées. Elle est facilitée par l'emploi d'outils logiciels dont la construction présente elle-même des difficultés substantielles. Nous proposons d'aborder le problème du développement de ces outils par une technique de méta-modélisation, dans un environnement logiciel expérimental : le système MétaGen. Cet article décrit une expérience de reconstruction d'un de ces outils (InterSem, développé à Montréal) avec notre technique. A travers cette expérience nous montrons que de nombreux problèmes (rapidité d'écriture, facilité de maintenance et d'évolution) peuvent être ainsi résolus. |
| In the framework of a project whose main goal is to design a reengineering platfrom for legacy systems, we propose a rule-based approach for a systematic object-oriented transformation of a MERISE analysis. This work is an ongoing research which will lead to the realization of a semi-automatic tool to transform a MERISE analysis schema to an object-oriented analysis schema. In this paper we will present the restructuring process and the rules extracted from a real-world case provided by a company wishing to migrate to object-oriented techniques in order to improve its maintenance process and software quality. |
| In a system where classes are treated as first class objects, classes are defined as instances of other classes called {\em metaclasses}. An important benefit of using metaclasses is the ability to assign {\em properties} to classes (e.g. being abstract, being final, tracing particular messages, supporting multiple inheritance), independently from the base-level code. However, when both inheritance and instantiation are explicitly and simultaneously involved, communication between classes and their instances raises the {\em metaclass compatibility} issue. Some languages (such as Smalltalk) address this issue but do not easily allow the assignment of specific properties to classes. At the opposite, other languages (such as CLOS) allow the assignment of specific properties to classes but do not tackle the compatibility issue well. In this paper, we describe a new model of metalevel organization called {\em the compatibility model} which overcomes this difficulty. It allows \emph{safe metaclass programming} since it makes it possible to assign specific properties to classes while ensuring metaclass compatibility. Therefore, we can take advantage of the expressive power of metaclasses to build reliable software. We implemented this compatibility model in NeoClasstalk, a fully reflective Smalltalk. Our implementation extends NeoClasstalk's metaclass facility, enabling safe reuse and composition of class specific properties. This simplifies and enhances the use of metaclasses. |
| Dans un contexte de classes réifiées, les classes sont définies comme instances d'autres classes : les métaclasses. Il est alors possible d'attribuer des propriétés aux classes (être abstraite, avoir une seule instance, ...) par le biais de leurs métaclasses. Cet article traite de la problématique de la composition des métaclasses. L'utilisation des métaclasses structure les applications en niveaux d'abstraction qui peuvent communiquer entre eux. Lors de la composition de (méta)classes, des problèmes dit d'incompatibilité apparaissent du fait des communications entre niveaux. Certains langages (par exemple Smalltalk) privilégient la compatibilité au détriment de la composition des propriétés de classes. Tandis que d'autres langages (par exemple CLOS) privilégient la composition des propriétés de classes au détriment de la compatibilité. Partant du modèle des hiérarchies parallèles de Smalltalk, nous définissons un pattern de compatibilité. Il permet de garantir la compatibilité entre niveaux d'abstraction tout en autorisant la réutilisation et la composition de propriétés de classes. Notre implémentation du pattern de compatibilité a montré qu'il permet une composition fiable des metaclasses, ce qui facilite et encourage leur utilisation. |
| Run-time features like reflection in object-oriented languages decrease application performance. In order to reconcile flexibility and performance, we adapt the standard partial evaluation process to deal with Java reflection API. This paper present a way to evaluate at compile time the meta-object computations that normally take place at run time. A classification of the Java reflective methods allows the partial evaluation process when to start and end. |
| Ce support d'exposé est dedié à la présentation de JavaBeans, l'architecture de composants associée à Java. Un bean java (un grain de café) est un composant logiciel réutilisable manipulable visuellement a l'aide d'outils de construction d'applications. Un bean est modélisé par une classe Java respectant des règles de constructions particulières (design patterns) accessibles au niveau du langage même par introspection. Après un court rappel des aspects avancés du modèle objet de Java incluant les processus légers (threads), la "serialisation" (linéarisation/reconstruction), les évènements et la réflexion nous détaillons la construction d'un premier bean . Cet exemple est l'occasion de démontrer différents environnements de développement et de générations d'applications Java dont ``VisualAge for Java'' d'IBM et la ``BeanBox'' de Sun. |
| What exactly are aspects? How to weave? What are the join points used to anchor aspects into the component program? Is there a general purpose aspect language? We address these questions for a particular but quite general class of aspects: aspects which can be described as static, source-to-source program transformations. We discuss the design of a generic framework to express aspects as syntactic transformations as well as a generic weaver. We also consider how to use semantic properties for the definition of aspects and how to implement these properties using static analysis techniques. As an application of the framework, we sketch how to describe and implement an aspect dealing with program robustness and exceptions. |
| Aujourd'hui, la complexité croissante des systèmes informatiques nécessite de trouver de nouveaux mécanismes d'abstraction pour améliorer la conception et l'implémentation des applications. Le paradigme de la séparation des aspects offre une approche intéressante pour permettre la réutilisabilité de composants logiciels. Dans cet article, nous proposons d'étendre ce paradigme pour prendre en compte l'évolutivité des systèmes pendant leur exécution. Cette extension, nommée adaptabilité dynamique des aspects, va permettre à un système de remplacer un aspect spécifique par un autre, pendant son exécution, sans affecter le reste du système. Dans le contexte des applications réparties, les concepts de séparation et d'adaptabilité dynamique des aspects contribuent grandement à la construction d'architectures ouvertes. Ils permettent en effet de modéliser, de réutiliser et d'adapter les nombreux mécanismes de répartition. Nous illustrons cette approche dans le cadre de la plate-forme CORBA. Dans un premier temps, nous établissons une correspondance entre aspects et réflexion, de façon à mettre en oeuvre la séparation et l'adaptabilité dynamique des aspects. Puis, nous présentons OpenCorba, un ORB ouvert, capable dadapter dynamiquement les stratégies de représentation et d'exécution du bus logiciel. |
| This paper presents an original approach to the development of object-oriented applications using MétaGen, the MetaCASE tool developed by the MétaFor team of Paris 6 University's CS Lab (LIP6). This approach addresses the crucial communication problem between users and developers by supporting the development of domain-specific languages. Moreover, even though the production of code from user requirements is not as automated as with more formal approaches, MétaGen supports the factorization of implementation knowledge for a whole application domain. This implementation knowledge is expressed in a first-order-logic rule-based system and is based on the use of state-of-the-art object-oriented technology such as application frameworks and design patterns. Our approach has been validated on real-size applications including the FIBOF ESPRIT IV project which is presented here. |
| Le langage de modélisation UML (Unified Modeling Language), soumis récemment à l'OMG (Object Management Group), est devenu un standard pour la modélisation d'applications par objets. A l'origine, UML a été défini à partir d'une fusion des méthodes Booch, OMT (Object Modeling technique) et OOSE (Object Oriented Software Engineering). Désormais, de nombreux ateliers de génie logiciel supportent ce langage de modélisation unifiée et l'utilisation de celui-ci dans le développement industriel d'applications par objets devient incontournable. Ce tutoriel d'introduction à UML présente une description : des concepts de base et de leur notation, des diagrammes graphiques constituant les différentes vues d'un modèle objet et d'une démarche de développement. |
| Software Engineering and object-oriented technologies represent expectations in supplying the high and increasing demand of the software market for products wit h guaranteed quality and of acceptable cost and performance. The quality is soug ht through the utilization of object-oriented methodologies since the stage of d esign and implementation until the stage of software's test. Nevertheless, the q uantification of this quality is taken into effect from adequate metrics. Actual ly, assuring an optimal level of quality is very difficult, since there are few systems that can effectively help designers and programmers to acquire more per formance in their activities. The aim of this paper is presenting a solution that helps the software designer in the improvement and maintenance of quality, in two situations: (1) in the diagnosis of quality of an existing system, and in the assessment of the best strategy of its modification; and^M (2) in the design, implementation and test of a new system project, either since its initial design (forward engineering process), or from an already-existing s ystem (reengineering process). The proposal is prone to the definition, design and implementation of an integra ted environment that aids and counsels on-line designers and programmers to incr ease the performance of their respective activities. The main techniques used in this approach come from Artificial Intelligence, particularly from the so-calle d Intelligent Systems (e.g. systems based on knowledge, multi-agents systems). This paper presents the following subjects: contextual diagnosis in intelligent systems; the main aspects treated in object-oriented systems; the modeling adopt ed for implementation of the proposal; and finally, the first conclusions about our research project. |
| 1997 |
| Créée en 1990 par le ministère de l'industrie, l'École des mines de Nantes est, après celles de Paris, Saint-Etienne, Alès et Douai, la cinquième de la lignée. Pour les premiers enseignants-chercheurs informaticiens venus rejoindre Nantes pour constituer l'ossature du futur département informatique, l'intérêt principal résidait dans l'aventure et le challenge intellectuel qu'implique la création d'une nouvelle école. Il s'agissait en fait de tirer le meilleur parti de cette opportunité rare qui consiste à décliner un nouveau programme pédagogique, à mettre en oeuvre de nouvelles équipes de recherche, et finalement à élaborer une politique de valorisation industrielle en phase avec la demande et les besoins du marché. Il se trouve que l'approche objet en général et la culture Smalltalk en particulier, "dopés" par l'implication d'OTI Inc, ont joué un rôle central dans la mise en place du triptyque enseignement, recherche, transfert de technologie à l'EMNantes, mais également dans la région des Pays de la Loire. |
| In this paper we develop in three phases a railway control system. We are mainly concerned with the \emph{software architecture} of the control system and its \emph{dynamic evolution}; we do not discuss here the implementation details of the components forming the control system. First, we informally discuss our design proposal for the architecture of the control system: a hierarchy of controllers whose leaves are local controllers connected in a network that mimics the underlying railway topology. Second, we formally define by means of particular \emph{graph grammars} a style of software architectures for the railway control system consisting of two complementary \emph{views} and ensuring several desirable properties by construction. The dynamic evolution of the architecture is modelled by a set of \emph{coordination rules} which define graph transformations and are \emph{verified} w.r.t. to the graph grammar. Third, using a coordination rule as a formal specification of a dynamic modification of the railway control system, we derive its implementation in ConCoord, a programming environment for concurrent coordinated programming. With regard to software engineering, the two first phases belong to the system design while the third one forms the first implementation step. |
| In order to exploit specialization opportunities that exist in programs written by researchers outside of the programming language community, a partial evaluator needs to effectively treat existing realistic applications. Our empirical studies have demonstrated that real-sized applications extensively use non-liftable values such as pointers and data structures. Therefore, it is essential that the binding-time analysis accurately treats non-liftable values. To achieve this accuracy, we introduce the notion of use sensitivity, and present a use-sensitive binding-time analysis for C programs which is obtained by a forward analysis followed by a backward analysis. This analysis has been implemented and integrated into our partial evaluator for C, called Tempo. |
| Since a binding-time analysis determines how an off-line partial evaluator will specialize a program, the accuracy of the binding-time information directly determines the degree of specialization. We have designed and implemented a binding-time analysis for an imperative language, and integrated it into our partial evaluator for C, called Tempo. This binding-time analysis includes a number of new features, flow-, context-, and return-sensitivity not available in any existing partial evaluator for an imperative language, which are critical when specializing existing programs such as operating system components. |
| In this short paper, we experiment reflective techniques dealing with the implemention of an ORB. We focus on a specific problem - the proxy representation - in order to emphasize the major advantages of the reflection, i.e. flexibility and reusability. More generally, in the context of the distributed computing, reflective languages provide a dynamic model allowing instrospection and modification of the policies and the mechanisms of distribution. |
| The main goal of this project was to design a semi-automatic tool which, from a Merise analysis schema, produces an OMT analysis schema. This work was based on a real-world case provided by a company wishing to migrate to object-oriented techniques in order to improve its maintenance process and software quality. We extracted translation and transformation rules, in a systematic way, from the existing Merise analysis of the case study. A comparison of both methods led to define a set of automatic rules and a set of concepts for which there is no correspondence between the two analysis representations. |
| 1996 |
| In 1992, we have described a reflective model for a prototype-based language based on the $lookup o apply$ reflective introspection protocol. In this paper, we augment our previous protocol by converting it to handle continuations reified as first-class objects. First-class continuations provide much more control over the current computation; during the introspection phase fired by message sending, they make it possible not only to change the behavior of the program for that message but also for the entire future computation. In this paper, we provide this introspection protocol with a formal semantics. This result is obtained by exhibiting a mapping $\Delta$ from program configurations to priority rewrite systems (PRS) as well as a mapping from message expressions to ground first-order terms used to query the PRS. Other advantages of this approach are: to ensure the termination of the introspection using the smallest set of formally justified conditions and to provide a clear declarative account of this reflective protocol. The PRS also appears as a meta-level to the base language, independent of the implementation, but from which we derive fundamental clues to obtain an efficient language processor. By our new model, we finally highlight the link between reflection in object-oriented languages and the one originally proposed by 3-Lisp although object-orientation provides reusability to reflection, making it easier to use. |
| The aim of this paper is to discuss metaclass composability and the related problems. We define inter-metalevel versus intra-metalevel composition, and downward versus upward compatibility. After analysing Smalltalk, SOM and Classtalk solutions, we present our latest research themes dealing with explicit metaclass composition. |
| Since 10 years we believe that metaclasses are powerful abstractions allowing to describe standard classes but also to model new classes dealing with new properties. Examples of such properties are well known and include abstract, single instance, primitive, automatic accessors, multiple-inheritance \dots\ In this paper we discuss the pros and cons of extending Smalltalk with explicit metaclasses |
| Existing OO methodologies focus on instance behaviors and reduce the role of a class to object creation. In fact, these methodologies do not address the issue of class design itself. Nevertheless, classes have their own properties, which are not related to the semantics of their instances. Examples of such properties are well-known and language independent~: concrete vs abstract classes, single instance vs multiple instances, subclassable vs non subclassable, single superclass vs multiple superclasses\ldots\ Some other examples are less known and more language dependent: named vs indexed instance variables, persistent vs non persistent, local vs remote\ldots This paper introduces a set of class properties in the context of Classtalk, a metaobject protocol for Smalltalk. It explicitly expresses these properties at the level of metaclasses, and gives a first taxonomy so as to better understand them. Then, it takes advantage of these explicit metaclasses to re-engineer some well-known Smalltalk class hierarchies. Such re-engineered examples give us the opportunity to raise the problem of metaclasses composition. They justify the use of explicit metaclasses to improve the design of class libraries. |
| Dans le contexte des langages à objets, nous établissons que les langages à classes ne permettent pas de représenter de manière satisfaisante des objets dont le comportement volue avec le temps au cours de l'exécution. Nous décrivons un protocole permettant aux objets de changer de classes dynamiquement. L'introduction d'un lien d'instanciation dynamique (changement de classe) modifie le paradigme de classe, en introduisant une dimension temporelle : un objet n'est l'instance d'une classe qu'à un instant t, et non plus tout au long de sa vie. Ceci renforce l'aspect comportemental des classes au détriment de l'aspect structurel. Il découle de cette approche une compréhension plus aisée des classes grâce à des définitions précises de celles-ci, la consistance de leur interface étant renforcée. Les échanges d'instances entre classes créent un nouveau schéma organisationnel, orthogonale à celui de l'héritage, faisant apparaître un nouveau lien que nous nommons : lien d'échange d'instances. Nous pensons que la prochaine évolution des langages à classes sera de prendre en compte les deux liens pour obtenir des librairies plus comphéhensibles, afin d'accroître leur réutilisation et leur maintenabilité, facteurs capiteaux intervenant dans le coût d'un logiciel. |
| As in the LISP tradition, SMALLTALK is almost entirely written in itself. It offers important advantages such as large portability, dynamicity, a fully unified world, graphical user interface builders, connection to databases, powerful development tools, etc. In this paper we discuss the trait that underlies all these features: REFLECTION. We quote one of its definitions and in the first part of this paper go through the different reflective aspects of SMALLTALK. We expand five major aspects in detail: meta-operations, the classes/metaclasses model, the reified compiler, message sending and the behavioral representation through the reification of the executive stack frame of each process. We illustrate their use with significant applications, based both on our industrial and research experiences. In the second part of the paper, we introduce and fully develop pre/post conditions in SMALLTALK, dealing with extensions of the model, the compiler, and the development environment. |
| 1995 |
| Les méthodes OO actuelles s'attachent surtout à décrire le comportement des instances d'une classe réduisant alors le rôle de cette classe à la simple création d'objets. En vérite, ces méthodes n'adressent pas le problème de conception de la classe elle-même. En effet, les classes possèdent leurs propres propriétés, indépendamment de la sémantique de leurs instances. Les exemples de telles propriétés sont déjà connus et sont indépendants des langages~: classe concrète vs. abstraite, instance unique vs. multiple, superclasse unique vs. multiple\ldots. D'autres exemples sont moins connus et/ou étroitement liés au langage lui-même~: variable nommée vs. indexée, objet local vs. distribué, objet persistant vs. objet volatile\ldots Ce papier introduit un ensemble de propriétés de classes dans le contexte de Classtalk, un protocole de méta-objets pour Smalltalk. Ces propriétés seront exprimés au niveau des métaclasses et une première taxonomie sera donnée pour mieux les appréhender. Ensuite, nous illustrerons quelques unes de ces propriétés avec un exemple de rétro-conception d'une hiérarchie Smalltalk lémentaire qui justifiera l'utilisation de métaclasses explicites pour la conception des bibliothèques de classes. |
| Les systèmes à objets, largement répandus à l'heure actuelle, apportent des concepts puissants de programmation et sont dotés de bibliothèques importantes de classes prédéfinies. C'est le cas notamment du système Smalltalk qui souffre d'une longue période d'apprentissage. L'un des objets de ce mémoire est de mettre en évidence la contribution des sciences de l'Education et de la psychologie cognitive pour étudier, expérimenter et développer les aspects pédagogiques de la programmation par objets, en particulier pour le système Smalltalk. Cette contribution se traduit soit par le développement de matériaux éducatifs (logiciels et environnements spécifiques), soit par des expérimentations menées sur le terrain avec des enfants ou des adultes qui ont permis de répertorier les principales difficultés rencontrées et d'observer les stratégies des experts. Par ailleurs, il vise à montrer comment l'utilisation de techniques, telles que la visualisation graphique et le typage, permet d'introduire du dynanisme dans les outils trop statiques de l'environnement de programmation Smalltalk et par conséquent apporte une aide aux tâches de conception et de maintenance. |
| Rapport final du contrat Armines-OTI 93-95 |
| 1994 |
| The enhanced metalevel architecture for Smalltalk, Classtalk, is very likely to interoperate with SOM system, since both of them are based upon explicit metaclasses, in the line of the ObjVLisp model. This paper exposes how to model SOM kernel into Classtalk, so as to import external SOM components into Smalltalk. |
| 1993 |
| 1992 |
| no year |
This material is presented to ensure timely dissemination of scholarly and technical work. Copyright and all rights therein are retained by authors or by other copyright holders. All person copying this information are expected to adhere to the terms and constraints invoked by each author's copyright. In most cases, these works may not be reposted without the explicit permission of the copyright holder.
Les documents contenus dans ces répertoires sont rendus disponibles par les auteurs qui y ont contribué en vue d'assurer la diffusion à temps de travaux savants et techniques sur une base non-commerciale. Les droits de copie et autres droits sont gardés par les auteurs et par les détenteurs du copyright, en dépit du fait qu'ils présentent ici leurs travaux sous forme électronique. Les personnes copiant ces informations doivent adhérer aux termes et contraintes couverts par le copyright de chaque auteur. Ces travaux ne peuvent pas être rendus disponibles ailleurs sans la permission explicite du détenteur du copyright.
This document was translated from BibTEX by bibtex2html