Alumni

EMOOSE's thesis dissertations

AGUIRRE, Javier (Colombia)

Title: IPSComp: Intelligent Portal for Searching Components.
Abstract: The software development industry is seeing as an inaccurate science, always dealing with low product quality and over run in time, cost and effort factors. Component Based Software Development (CBSD) has emerged as an approach aiming to improve a number of drawbacks found in the software development industry. The main idea is the reuse of well-tested software elements that will be assembly together in order to develop larger systems. This approach will bring as a consequence the reduction in time development, a more stable final product and a reduction in time, effort, cost and testing process. Despite the goal CBSD is aiming, software industry has not been able to accomplish such objectives. The purpose of this research is to present means to provide users with the appropriate tools to describe components, in order to be able to share them among a wide consumer’s community. On top of such component description, tools to discover and search for components can be implemented. The set of users in this case can be identified as different actors, such as software developers, software architects, software producers and systems integrators, among others. In this context, my research focuses on two main parts: the first one is related to component ontology, and the second on code and design transformation for the integration of software component repositories.
Aguirre, Javier

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Romanczuk Requile, Annya (Ecole des Mines de Nantes, France)
File(s): [pdf - 1.31 MB] 

AN, Keqiang (China)

Title: Semantic Services Discovery in .NET.
Abstract: Recent trends on ubiquitous computing have created new requirements for discovering and using the available services in the network. This leads to require semantic interoperability between heterogeneous entities, which means to realize dynamic ontology to exchange semantic information and configure automatically.
This thesis mainly concentrates on semantic discovery of service components. A survey of the state of the art in services discovery is provided, and two key procedures, dynamic adaptation and effective searches are being focused on. Having given a comprehensive survey of all major research being conducted in the area of ontology construction, the thesis proposes a generic approach to the semantic service discovery that allows establishing dynamic adaptive ontology by using RDF/S to facilitate the description of service components. And the prototype also provides the mechanism to combine the ontology infrastructure with conceptual retrieval module which is a powerful reasoning engine to acquire high performance on searching process. Conjunctive with Microsoft web service strategy, the architecture can be reflected on .NET platform eventually. Based on several foundation techniques an implementation has been developed for the architecture. Together with a handheld device application, a walkthrough scenario is performed to estimate the work.
An, Keqiang

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Menaud, Jean-Marc (Ecole des Mines de Nantes, France)
File(s): [pdf - 354 K]  [ppt - 527 K] 

AREVALO, Gabriela B. (Argentine)

Title: Object Oriented Architectural Description of Frameworks.
Abstract: Nowadays, the existing formalisms to represent software architectures (such as box and line drawings) fail in providing a clear semantics and only give an intuitive picture of the system as a whole, which is not enough as a valuable description. More specifically, the framework architectures should show the overall design and the specification of the points of variability of the framework, making easier the reuse of the architecture, integration with other frameworks and a reference to measure the changes in subsequent versions of the frameworks. Starting from several frameworks, we propose, as a first step, to study and compare the various levels and expressive power of two formal approaches, such as architectural patterns and Wright an architectural description language. Next we study the possible complementarity of these approaches, and also evaluate the flexibility of the descriptions in order to be able to take evolution aspects into account. The final objective is to propose a complete description of a framework based on the previous results.
Arevalo, Gabriela B.

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Borne, Isabelle (Ecole des Mines de Nantes, France)
File(s): [pdf - 701 K] 

ARGAñARAZ, Veronica (Argentine)

Title: Managing Traceability Conflicts with Reuse Contracts.
Abstract: Software systems are subject to evolution throughout their life cycle. When evolving software components in a certain development stage, it is necessary to identify the potential consequences of this change in components of other stage, it is necessary to identify the potential consequences of this change in components of other stages. to improve the maintainability and reliability of software, it would be useful to have a methodology that manages the impact of changes between components in different stages. In this thesis, we propose to use and extend the reuse contracts methodology to formally document traceability dependencies and check evolution conflicts between components in differences cycle stages.In particular we will focus on design and complementation stages, using UML as a modeling language. To validate the approach, we will build a prototype tool and will apply it to an industrial case.
Argañaraz, Veronica

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     D'hondt, Theo (Vrije Universiteit Brussel, Belgium)
File(s): [zip - 447 K] 

ARROYO, Victor Hugo (Chile)

Title: Aspect Oriented Programming for Features in Telecom Applications.
Abstract: The Telecommunications systems have evolved rapidly as much as new additional functionality must be integrate to the old system. The old plain Telephony service (POTS) cannot be always re-engineered for economical or technical (or both) reasons, the industry has invested great effort in develop software-switching system, many of which are extremely precarious and were developed without the advantages of the modern software and current technologies. The fundamental source of problems derives from the changing system requirements, in the sense of "features" which must interact with the old system and with features already integrated, almost always in an unanticipated and imprecise ways. In practical terms, Features Interaction can be appreciated when a feature interact with behavior of another feature and obviously the quality of the services may be compromised, it make relevant that an adequate management must consider it self as be able to detect those interactions and resolve them in a suitable way. In this Master Thesis the problems of Features Interaction will be analyzed under the point of view of AOP by using AspectJ.
Arroyo, Victor Hugo

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Dounce, Rémi (Ecole des Mines de Nantes, France)
File(s): [ppt - 211 K]  [pdf - 821 K] 

BARONI, Aline Lucia (Brazil)

Title: Formal Definition of Object-Oriented Design Metrics.
Abstract: Software measurement has become essential to good Software Engineering. However, most published works on software engineering concentrate on the coding activity. As quality indicators and predictors of structural problems, metrics should be available as early as possible in the software life cycle, and not dependant on source code availability.
This thesis intends to assist object-oriented software measurement, improving its use among software designers. For achieving this goal, the FLAME - a Formal Library for Aiding Metrics Extraction - is built with The Object Constraint Language (OCL), a part of the Unified Modeling Language (UML) standard. Based upon OCL, object-oriented design metrics definitions are formalized on a compositional way.
The definition of each metric is done upon the UML meta-model, at different levels of abstraction, including the meta-classes Package, Model Element, Generalizable Element, Classifier, Feature, Operation and Attribute. The combination of the UML meta-model and OCL allows unambiguous metrics definition, which in turn helps increasing tool support for object-oriented metrics extraction.
The outcome is an elegant, precise and straightforward way to define metrics that may help to overcome several current problems. Besides, it is a natural approach since we are using the object technology to define metrics on the object technology itself.
The formalization renders possible the comparisons among different sets of metrics, as well as it may be used to establish a common vocabulary among different stakeholders. As consequence, our efforts contribute to the overall quality of the Software Engineering product and process.
Baroni, Aline Lucia

  
Welcome Institution:
     Universidade Nova de Lisboa (Portugal)
Advisor(s):
     Brito e Abreu, Fernando (Universidade Nova de Lisboa, Portugal)
File(s): [pdf - 1.91 MB] 

BENAVIDES NAVARRO, Luis Daniel (Colombia)

Title: DHAMACA: An Aspect Oriented Language for explicit distributed programming.
Abstract: The development of distributed applications with current programming languages is a difficult task. Aspect oriented programming (AOP) promises to provide means for encapsulation of the so-called crosscutting concerns. However few approaches with language support for distribution have been developed. This thesis introduces Dhamaca, an AOP language with explicit support for distribution. The Dhamaca language is designed as an extension of the Java language. It provides constructs for remote pointcuts (in particular cflow and seq), distributed advice, aspects and neighborhoods. Some Examples are presented to show how Dhamaca can be used to write distributed applications. In particular it has been shown how a replicated cache implementation is easily realizable compared to implementations using standard Java platforms, such as JBossCache. A prototype of Dhamaca, developed by extending JAsCo, is also presented
Benavides Navarro, Luis Daniel

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Sudholt, Mario (Ecole des Mines de Nantes, France)
File(s): [pdf - 261 K] 

BOBEFF, Gustavo Javier (Argentine)

Title: ARCoM (Another Reusable Component Model).
Abstract: Component-based software development has proven effectiveness for systems implementation in well-understood application domains, but is still insufficient for the creation of reusable and changeable software architectures. Applications build on components that prevent the dilution of design decisions seems to be a suitable solution. The aim of this thesis is the definition of a reusable component model where the design decisions can be kept through any composition mechanism. The component design used for our model, named ARCoM(Another Reusable Component Model) was conceived for software design, but always keeping a mapping with the implementation artifacts in object-oriented programming, that is, classes and relationships.
Bobeff, Gustavo Javier

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Romanczuk Requile, Annya (Ecole des Mines de Nantes, France)
     Oussalah, Mourad (Université de Nantes, France)
File(s): [pdf - 885 K] 

CÁDIZ, Alfredo (Chile)

Title: Consistency Management in Event-Driven Applications.
Abstract:
Cádiz, Alfredo

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mostinckx, Stijn (Vrije Universiteit Brussel, Belgium)
     Vallejos, Jorge (Vrije Universiteit Brussel, Belgium)
File(s):  

CASANOVA, Miro (Chile)

Title: Automatic software Evolution Based on Type Information.
Abstract: Typecasts difficult the task of reusing and maintaining software. They are often seen as a signal of bad design and implementation. In programming languages which do not support genericity, programmers are obliged to make typecasts throughout the entire program.
Casanova, Miro

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     D'hondt, Theo (Vrije Universiteit Brussel, Belgium)
File(s): [zip - 231 K]  [pdf - 631 K]  [ps - 1.01 MB] 

CASARINI, Gabriel (Argentine)

Title: Towards Transparent Strong Mobility Using a Reflective Smalltalk.
Abstract: An object-oriented language is said to be reflective if it allows to handle and extend entities that are usually implicit. As a reflective language, Smalltalk provides access to many entities such classes and methods. However, its capabilities to control program execution are limited. in order to fix this weakness, an extension named MetaclassTalk, has been developed at EMN.
The aim of this thesis is to explore the expressiveness of MetaclassTalk in order to achieve Transparent Strong Mobility. That is, allowing the migration of parts of a program from one node of the network to another one without stopping its execution. Thanks to the use of reflection, mobility can be introduced transparently without mixing application domain code with mobility code. This work lead to the design and implementation of a new version of MetaclassTalk on top of Squeak, a free Smalltalk written in itself.
Casarini, Gabriel

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Ledoux, Thomas (Ecole des Mines de Nantes, France)
     Bouraqadi Saâdani, Noury (Ecole des Mines de Nantes, France)
File(s): [pdf - 5.92 MB] 

CASTRO MEJÍA, Sergio (Ecuador)

Title: ACTA DEPENDENCIES AS A UNIFIED MECHANISM FOR COMPENSATION, ACTIVITIES SYNCHRONIZATION AND FUNCTIONAL REPLICATION IN BPEL4WS.
Abstract: Advanced transaction management in loosely coupled environments is not a trivial task. Web Services are the current state of the art for interoperability for such kind of systems, and the BPEL4WS language is nowadays the de facto standard for web services composition in industry. However, the BPEL4WS strategy for expressing transactional properties is limited, non extensible, and relies on different unrelated constructs for managing the concerns of activity synchronization, functional replication and activity compensation. We believe that these concerns should be managed using a more simpler, extensible and unified set of constructs, relying on well proved existing formal models for advanced transaction management. In this work we introduce such a composition framework called DBCF (Dependency Based Composition Framework). DBCF demonstrates the viability of our conceptual model in service composition languages. In addition, we present an extension for BPEL4WS that adds these features, and suggest ways of describing declaratively transactional properties expressed with our proposed extension using aspect oriented technologies.
Castro Mejía, Sergio

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Johan Fabry (Vrije Universiteit Brussel)
File(s): [pdf - 704 KB] 

CHEN, Yan (China)

Title: Aspect-Oriented Programming (AOP): Dynamic Weaving for C++.
Abstract: Due to the fast development of Internet services and the huge amount of network traffic, it is becoming an essential issue to reduce its user-perceived latency. Although Web performance is improved by caching, cache can provide more benefit than nowadays: prefetching reduces user access time, at the expense of increasing traffic. Performance measurement of prefetching techniques are made primarily in terms of hit ratio and bandwidth usage. A significant performance factor for a prefetching algorithm in its ability to reduce latency is deciding which objects to prefetch in advance. Nevertheless, to achieve the best performance, the prefetching policy must match user access patterns and Web server characteristics. This implies that new prefetching policies must be loaded dynamically as needs change.
Recent 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 (AOP) is a natural technique to address this issue. Actually, µDyner, a Dynamic Weaver on native code address to provide dynamic weaving of aspects targeted toward C applications. It provides lower overhead for aspect invocation than other dynamic approaches, thus meeting the performance needs of Web caches [22]. But, the unique main language supported by µDyner is the C language.
The main goal of this dissertation is to realize a study on a dynamic weaving mechanism for the C++ language and upgrade µDyner to support this new feature.
Chen, Yan

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Menaud, Jean-Marc (Ecole des Mines de Nantes, France)
File(s): [pdf - 382 K] 

CIBRAN, María Agustina (Argentine)

Title: Using Aspect-Oriented Programming for Connecting and Configuring Decoupled Business Rules in Object-Oriented Applications.
Abstract: This thesis addresses the problem of decoupling business rules from the core software application. By business rules we identify constraints or statements of the kind “if then” that specify part of business knowledge.
The problem with business rules is that they are usually represented implicitly, scattered across many places in the code and even tangled with code that addresses other concerns. Moreover, they tend to change faster than the rest of the application to accommodate changes in business considerations. As a consequence, because of the way business rules are represented, it is hard to localize and change them, resulting in invasive changes to the code. Thus, the whole software becomes difficult to understand, maintain, evolve and reuse.
To deal with these problems separation of concerns is fundamental. The goal of this dissertation is to decouple business rules in order to achieve a high degree of flexibility by allowing easy plugging and unplugging of rules into the software applications depending on the business needs. We especially focus on connecting decoupled business rules with the rest of the application. It is out of the scope of this dissertation to focus on the representation of the business rules.
The first contribution of this thesis is the categorization of business rules followed by a detailed analysis of the requirements for a mechanism for decoupling business rules and their subsequent connection with the rest of the application. As many of these requirements coincide with the ideas behind Aspect-Oriented Programming, an aspect-oriented approach is used, using AspectJ as the concrete aspect-oriented programming language to perform the weaving of the rules into the applications.
As a second contribution we present a detailed description of the necessary ingredients for the decoupling, configuration and application of business rules. Generic solutions are provided and illustrated with examples from a case study.
Cibran, María Agustina

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     D'Hondt, Maja (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - 618 K] 

CONSTANT, Olivier (France)

Title: An Agent-Based Platform for Assisting Repository Navigation and Administration (Part of the LEOPARD Project).
Abstract: Repositories can be hard to navigate and administrate. Standard static access techniques like indexing have limited power and flexibility and their maintenance requires appropriate feedback. Users, administrators and content providers are all concerned by this issue. It has become all the more critical as the successful emergence of learning objects leads to the creation of very large and complex repositories.
We propose an approach strictly based on the dynamic collection of users' navigation pathways for allowing for the effective use of large repositories. The computation of pathways allows for the inference of virtual semantic links between resources of the repository. Hence users can be assisted in their navigation dynamically based on pathways from their personal profile but also from the whole community of users including experts. In addition, pathways are a potential source of feedback for repository administrators and content providers. Possibilities include the discovery of communities of users and categories of content.
A prototype has been designed as a multiagent system. To allow for its implementation, an agent infrastructure and agent framework have been developed for MS .Net. The prototype is an experimental platform that demonstrates how pathways can be collected and how assistance can be provided for the navigation of a repository of web pages. It also intends to be a research platform for a future extraction of feedback and the development of advanced algorithms for a better assistance.
Constant, Olivier

  
Welcome Institution:
     Monash University (Australia)
Advisor(s):
     Romanczuk Requile, Annya (Monash University, Australia)
File(s): [pdf - 395 K] 

CUCHE, Jean Sebastien (France)

Title: Expressing Information-Access Rules in Object-oriented Conceptual Model..
Abstract: Currently, access to information in object-oriented systems is usually done the same access to database records without taking advantage of object-oriented concepts (through simple forms and with an access control only at the database management level). The project aims at extending a standard object-oriented modeling languages, UML, to be able to express information-access rules. The formal definition of the access rules will be validate by the development of an application for the Visionnaire company. Development after the formal definition of access rules, this application will provide the users with interfaces specific to their given authorizations.
Cuche, Jean Sebastien

  
Welcome Institution:
     Pontificia Universidade Catolica do Parana (Brazil)
Advisor(s):
File(s):

DE MUYNCK, Wim (Belgium)

Title: Bridging the Gap between XML and Hypermedia: A Layered Transformational Approach.
Abstract: In this thesis we will discuss the Extensible Markup Language or XML, recently adopted by the WWW community as d replacement to previous approaches, wrt. the well-established research field of hypermedia. A thorough understanding will be given of what this research area is about, what its basic concepts, terms and definitions are, and how it relates to current hypermedia implementations such as the WWW. Starting from its historical background and core ideas, the XML language will be introduced, and we will also mention its current applications, additions, and improvements. An evaluation will point out that it has some interesting benefits and capabilities to describe information, but that it also lacks navigational modeling wrt. hypermedia. As this may cause maintenance issues, we propose a generic solution to this, based on the Object-Oriented Design Methodology (OOHDM). To that extent, we introduce a compact specification language, present a metatransformation implementation that uses Extensible Stylesheet Transformations (XSLT), and discuss a validating example.
De Muynck, Wim

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentine)
Advisor(s):
     Rossi, Gustavo (Universidad Nacional de La Plata, Argentine)
File(s):

DE SOGOS, Diego (Argentine)

Title: Component Generators: Towards Adaptable and Efficient Software Components.
Abstract: The notion of Software Component offers to developers a possibility to deliver self-contained executable pieces of program that can be integrated into a system. Using components, the software industry can create a market of interchangeable parts as in many other industries like hardware, automobile, etc. Adaptability is vital in this kind of markets. However, the type of adaptability offered in existing component models relies on customizing components by setting some parametrized values, keeping unchanged the structure and operation of the component. This superficial adaptation of software results in inefficient components. Specialization techniques like partial evaluation or slicing cannot be straightforwardly applied to software component implementations, just because the adaptation is done at consumption time, when implementation is in most cases unavailable.
We propose a software component development process that integrates specialization techniques while preserving a black-box model of composition. In order to do that, we extend the definition of a component to include specialization opportunities as part of its interface. To avoid breaking the black-box model, we replace the delivery of a single component by the delivery of a component generator, which will be in charge of producing specialized versions for each of the published specialization opportunities (this kind of generator can be conceived as a generating extension, widely studied in the field of partial evaluation). Specialization can be automatically triggered when the consumer, instead of connecting components, put component generators together and provides the concrete values for specialization.
This work differentiates from previous efforts in the sense that specializable components can be delivered without determining static dependencies with other components (i.e. required services).
De Sogos, Diego

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Noyé, Jacques (Ecole des Mines de Nantes, France)
File(s): [pdf - 1.80 MB] 

DE VOS, Kristof (Belgium)

Title: Comparison between different Tree Flattening techniques in an Indirect Reference Listed DGC.
Abstract: Distributed systems are becoming more and more common to solve the problem of needing more resources like memory or processing power. Although these resources can have enormous capacities, they are still limited. Therefore, Distributed Garbage Collection (DGC) algorithms were invented to free memory that is not used any more by other processes.
Applying local GC-techniques unchanged on a distributed system would cause unacceptable delays or would freeze the system for a too long time. One of the most promising techniques is Indirect Reference Listing (IRL), which distributes the management of keeping track of remote references. This results in an inverse tree, called the diffusion-tree.
Unfortunately, IRL has as side effect that it can create unbalanced and very deep trees, which are bad because they can contain zombie references and create third- party dependencies. This thesis focuses on different techniques to minimize the depth of this tree. Different strategies will be compared to each other in a theoretical and practical manner. More concretely, the tree-rerouting technique from Luc Moreau will be compared against native IRL and a new technique.
De Vos, Kristof

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Piquer, José (Universidad de Chile, Chile)
File(s): [ppt - 461 K]  [pdf - 537 K] 

DEDECKER, Jessie (Belgium)

Title: Dynamic Aspect Composition using Logic Metaprogramming.
Abstract: Separation of concerns has always been one of the most important goals in computer science. However, not all concerns can be easily modularized in the current programming languages. This resulted in the fact that some concerns are implemented ad-hoc, that is by placing code that is spread across one or more modular units. Such code is often called tangled or crosscutting code. Crosscutting code results in software that is less reusable, less readable and harder to maintain. Several programming tools have been proposed to modularize these crosscutting concerns in aspects. Many of these programming tools for advanced separation of concerns are built by creating or modifying the compiler of the existent languages that weave the crosscutting concern in the code. However, modifying a compiler makes it difficult to introduce aspects at run-time. Introducing aspects at run-time is particularly useful in distributed applications, where the crosscutting concerns can depend on the machine where the object is located, thus requiring aspects to be woven each time an object is migrating over the network. In this dissertation we propose a composite aspect object to support dynamic weaving of aspects. Furthermore, we propose to compose these composite aspect objects using a logic meta programming language. A logic meta programming language allows us to reason about the source code and the structure of the base level in a declarative style. Reasoning about the source code is useful in a dynamic context, because it allows to adapt our composition strategy depending on the changes that are made at run-time. Our model for dynamically typed object oriented languages defines a meta-architecture that configures the meta-object protocol using logic meta programming rules for supporting dynamic aspect compositions.
Dedecker, Jessie

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentine)
Advisor(s):
     Prieto, Máximo (Universidad Nacional de La Plata, Argentine)
File(s): [pdf - 558 K] 

DEL VALLE, Joao (Brazil)

Title: Towards round-trip engineering using logic metaprogramming.
Abstract: Round-trip engineering is a popular technique for software development. A development environment with round-trip engineering support normally provides two views of the software system: one view is the source code, containing the implementation of the software itself, and the other view is more abstract, giving a global picture of the design of the system. If changes are made in the source code, the environment is responsible for propagating them to the diagram view. Similarly, if the diagram view changes, the changes are propagated to the code.
Many industry-level tools provide support for round-trip engineering. However, there is no general approach to it. Each tool implements its own strategy for mapping code constructs to diagrams and vice versa. Moreover, tools provide very limited options for customization, enforcing the developer to adapt his development practices to the tool instead of being able to adapt the tool to his needs.
We propose logic metaprogramming (LMP) as an approach for constructing more customizable round-trip engineering tools. LMP is the use of logic programming to reason about source code at meta-level. In this thesis, we show how it can be used for extracting diagrams from the code and generating code from diagrams. Besides the advanced reasoning power, we believe that the use of logic rules can lead to a clear, general and more flexible approach map between source code and diagrams.
In thesis, we focus on UML class diagrams to describe the design of the software system, and Java as the source code language. We validate our approach with the implementation of extsc{Lure}, a prototype tool for round-trip engineering.
Del Valle, Joao

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mens, Kim (Université catholique de Louvain, Belgium)
File(s): [pdf - 841 K] 

DIERICKX, Ilse (Belgium)

Title: Patterns and Frameworks for Framework Documentation.
Abstract: The main goal of this research project is to study different ways to document object-oriented application frameworks and to implement a generic substrates supporting this kind of documentation. In particular we want to study documents based on patterns, cook-books, hot and frozen spots, hypermedia and animations and integrate these documents into the framework´s class structures. Taking into account that we will use many documentation strategies that besides will also have to be plugged into different framework´s structures, we will need to cope with these variations using different object-oriented approaches: first we will find patterns of software documentation; these patterns will allow us to understand different strategies that are used to document framework. From this set of patterns we will derive different connection structures among documentation classes and among documentation and framework classes; this abstract structure will help us a generic documentation framework.
Dierickx, Ilse

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentine)
Advisor(s):
     Rossi, Gustavo (Universidad Nacional de La Plata, Argentine)
File(s): [zip - 880 K]  [pdf - 1.34 MB]  [ps - 8.19 MB] 

EBRAERT, Peter (Belgium)

Title: Tool Support for Partial Behavioral Reflection.
Abstract: More and more programmers use aspect-oriented programming and reflection in order to make a clean separation of concerns in their programs. Currently very few tool support is provided for any of those programming paradigms. It is obvious that good tool support is indispensable for promoting the application of these paradigms.
The goal of this thesis is to provide some tool support for developing reflective applications. Throughout the research, Reflex is used as a case study. It is a Java framework that allows a kind of reflection, permitting a clean separation of concerns in its way.
After a study of the problem environment, we explain the static and dynamic tool support developed in this thesis. Typically, static tool support will be used at development time, while dynamic tools will be used at runtime. At the static level, we help the programmer by easing the Reflex configurations and by detecting and resolving configuration conflicts. At the dynamic level we used Reflex itself in order to create a runtime monitor, allowing programmers to dynamically monitor both standard object-oriented and reflective Java applications built with Reflex.
Ebraert, Peter

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Piquer, José (Universidad de Chile, Chile)
File(s): [pdf - 1.10 MB] 

FABRY, Johan (Belgium)

Title: Full distribution transparency, without losing control - AOP to the rescue.
Abstract: When building a distributed system, an important issue is how the aspect of distribution is treated. Ideally, the fact that the system is distributed should not pose an extra burden on the programmer. This idea is usually referred to as "distribution transparency". To achieve this transparency, a number of abstractions have been developed to separate the concern of communication between the different programs in the distributed system from the base functionality. However, none of these abstractions provide full distribution transparency while providing the programmer with a large degree of control. A recurring obstruction to full transparency is, specifically, the error-handling required for remote procedure calls.
To be able to achieve distribution transparency we should be able to reason about the program without continuously having to worry about possible errors at every method invocation. However, at a certain point in the development we should be able to concentrate on these failures and specify what to do when an error occurs. The idea here is to separate the concern of distribution out of the main application. The technique we will use to achieve this separation of concerns is Aspect-Oriented Programming (AOP).
The goal is to make it much easier for the programmer to write a distributed application than it currently is, using RMI or another distribution package. Specifically we will concentrate on what these packages do not handle adequately: error-handling. We will define three aspect languages to allow the programmer to specify the aspect of distribution separately from the main program, which is written in Java. We will implement an Aspect Weaver for these languages, which will generate Java source files and use the javac compiler to generate class files. The generated code will use Java's RMI as a transport layer for the remote method invocations.
Fabry, Johan

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Piquer, José (Universidad de Chile, Chile)
File(s): [zip - 260 K]  [pdf - 763 K]  [ps - 1.09 MB] 

FARíAS, Andrés (Chile)

Title: Towards a Security Aspect for Java.
Abstract: Current programming languages like Java allows the Development of programs dealing with different high-level concerns like concurrency, persistence, error recovery, security and so on. This kind of programs are very complex due to the mixing of code related to the concerns and the base code.
Aspect-Oriented Programming (AOP) is a new methodology targeted towards programming the formulation of executable programs by means of aspect which are separated from the base code. The main problems to be addressed then are the definition of the different aspect languages, how to reference entities of the base code and how to compile an AOP-style program into an executable.
I define formally the aspect of Security for Java in terms of program transformations. This task can be done using reflective properties of Java.
Farías, Andrés

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Sudholt, Mario (Ecole des Mines de Nantes, France)
File(s): [pdf - 973 K] 

GODERIS, Sofie (Belgium)

Title: Personalization in Object-Oriented Systems.
Abstract: Personalization is a concept with raising importance in web-applications. It intends to adapt an application to the user’s individual needs such that each user gets the idea that the system was created just for him/her and knows what he/she likes. Although it might seem obvious to personalize web-applications, personalization should be viewed in a broader perspective and the ideas of personalization can for instance be applied onto object-oriented systems. The dissertation discusses the personalization of object-oriented systems. The goal of this dissertation is to investigate how, why and where we can introduce personalization in object-oriented systems. We will do so by first studying existing approaches and make a comparison. Then we will introduce our approach for personalizing systems, i.e. logic meta-programming, a declarative meta-language that lets you reason about the structure of an object-oriented base-language. We will prove our proposed approach by showing examples for each different type of personalization.
Goderis, Sofie

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentine)
Advisor(s):
     Rossi, Gustavo (Universidad Nacional de La Plata, Argentine)
File(s): [ppt - 384 K]  [pdf - 518 K] 

GONZáLEZ, Sebastián (Colombia)

Title: Design and Implementation of a Reflective Hybrid Functional/Prototype-Based Language Kernel.
Abstract: A frequent dilemma in programming language design is the choice between a language with a rich set of notations and features, and a small, simple core language. In this work, the dilemma is addressed by proposing a syntactical and semantical extension mechanism based on the programming language Pic% developed at VUB. The result is a language whose kernel is basically a reduction of Pic%'s. This kernel defines a very simple functional language whose core syntax and semantics can be grown as needed. The extension process is performed from within the language itself, using a set of reflective facilities, and such process is dynamic (i.e. performed at run-time), thus enabling the programmer to use new constructs as soon as they are defined. The tools provided are: a small and well-defined core semantics, an evaluation environment playground, and a set of meta-level functions which conform the meta-level interface (MLI) of the language. The MLI contains utilities to extend the language grammar and assign a semantics to each extension. With these tools, it is shown that a complete and consistent object-oriented model can be defined by means of syntactic extension and assignment of the corresponding semantics. The OO layer is inspired on prototype-based programming, thus the language, called xPic% (extensible Pic%), is transformed to be both a functional and a prototype-based programming language. As far as we know, an MLI for this kind of combination is unique.
González, Sebastián

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     De Meuter, Wolfgang (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - 763 K] 

GUPTA, Richa (India)

Title: A wrapper API for Reflex.
Abstract: Reflex is a versatile kernel for multi-language Aspect-Oriented Programming (AOP) which also provides building blocks to help implement different AO languages. The objective of this AOP kernel is to support and combine a large range of Aspect approaches. Reflex has mainly focused on ‘behavior-oriented’ aspect languages. In order to verify the versatility of AO approaches, it is also necessary to consider aspect languages which are interested in the structure of aspects, such as Caesar. Caesar has focused on the issue of structuring aspects and the relationship between this structure and the structure of the base program. Thus Caesar gives the structural point of view. It is a language which uses the concept of wrappers and collaboration to achieve binding between aspects and components. Wrappers are not directly supported by Reflex. This thesis exposes the development of a wrapper API which was integrated with Reflex in order to extend the Reflex API so that wrappers can be directly supported. An example was also developed to show how this wrapper API can be used to develop an aspect and component language.
Gupta, Richa

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Noyé, Jacques (Ecole des Mines de Nantes, France)
File(s): [pdf - 227 K] 

HERNANDEZ, Mariana (Mexico)

Title: User-Adaptable Context-Aware Applications in a Mobile Environment.
Abstract:
Hernandez, Mariana

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mostinckx, Stijn and Herzeel, Charlotte ( Vrije Universiteit Brussel, Belgium)
File(s): [pdf - K] 

KESSLER, Benoit (France)

Title: Declarative composition of structural aspects.
Abstract: While designing applications with multiple crosscutting concerns, implemented as aspects, interactions can occurs among these aspects. To resolve these interactions, aspects need to be composed.
Admittedly, a crucial part in aspect composition lies in the detection of the interactions. As a matter of fact, aspects typically use intentional definitions of their cuts, so the developer can have trouble foreseeing the possible interactions between a given aspect and the base code, and between several aspects. It is therefore crucial that the aspect-oriented system detects and reports on interactions.
Once the interactions have been detected and identified, they shall be resolved using declarative composition mechanisms. A common example of such mechanism is tools for ordering the aspects at a shared join point.
In this report, we propose a solution for detection of interactions among structural aspects, that is to say aspects modifying the structure of classes, in Reflex. This solution is based on a logic engine connected to Reflex and which is used to reason about the aspects and how they interact. We also propose some advanced tools for interaction resolution.
Kessler, Benoit

  
Welcome Institution:
     DCC, University of Chile (Chile)
Advisor(s):
     Tanter, Eric (DCC, University of Chile, Chile)
File(s): [pdf - 750 K] 

LABBE, Emmanuel (France)

Title: A Conceptual Object-Oriented Model for Complex Geographical Entities - the DDCO model -.
Abstract: The modeling of complex entities or phenomena in geographical information systems has to face numerous problems due to the highly variable attributes they are composed of. Moreover, each particular type of GIS objects to model seems quite different from the others, and finding a global design approach has hardly succeeded until today.
The object-oriented paradigm has proven itself to be a good modeling approach, and coupled with an appropriate design methodology it can facilitate the modeling of such entities. This work defines a new way to represent geographical objects by abstracting them in a common and uniform conceptual model. To cope with the complexity of GIS objects, this work tries not to focus on the dimensions objects or phenomena could be composed of, but on the dependencies that relate these dimensions.
This abstraction brings uniformity in the development of a geographical application. The same mechanisms are used to model every GIS objects. Therefore, a kind of methodology design approach logically comes from the model abstractions. It gives the bases for future object-oriented frameworks that would enable to easily conceive geographical application manipulating complex objects or phenomena.
Labbe, Emmanuel

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentine)
Advisor(s):
     Gordillo, Silvia (Universidad Nacional de La Plata, Argentine)
File(s): [pdf - 506 K] 

LIANG, Peng (China)

Title: Formalization of UML using Algebraic Specifications.
Abstract: UML is a standard graphical modeling language; it presents a set of notation for visualizing, specifying, constructing, and documenting a software-intensive system. And it demonstrated that it is a well-suited approach to analyze and design complex systems such as industrial ones. But UML is not a formal language; it is composed by graphical notation, natural language, mostly means English, and formal language, OCL, for example. It gives a syntactic description of the language but not a complete and precise specification of it semantics. This can always lead to confusion and different understanding when we analyze a model. To improve software reliability and reusability, the use of formal specification is necessary but it may be difficult. My thesis work is trying to present an algebraic semantics framework for UML, focus on the dynamic part, and defining a set of translation rules between UML model and algebraic specification. At last, we use Larch Prover – a theorem prover, to validate and verify the formal specification of UML models, which can lead to early detection of errors and inconsistencies in the software development process. Meanwhile, tools are needed to assist the formal specification process, besides to prove or to verify some parts. We present the implementation of the translation tool using XMI standard and the XML4J parser based on the Rational Rose UML CASE tool. And In my thesis, I propose a method to formally specify concurrent and communicating components with data in UML.
Liang, Peng

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Romanczuk Requile, Annya (Ecole des Mines de Nantes, France)
     Royer, Jean-Claude (Université de Nantes, France)
File(s): [ppt - 627 K]  [pdf - 741 K] 

LOPEZ PARUMA, Oscar Andres (Colombia)

Title: A Forward-Chaining Inference Rule Engine for a Prototype-Based Language.
Abstract: One of the fundamental research areas in computer science is concerned with representing and inferring knowledge from information. Through the years, many techniques have been proposed to solve the related difficulties, either separately, or by combining knowledge representations with knowledge inference. In this dissertation, prototype-based languages, as an expressive knowledge representation, are combined with forward-chaining rule-based reasoning, as a mechanism to infer knowledge. More specifically, we pro- pose that a forward-chaining inference engine on top of a prototype-based language, supporting a rule language, composed of expressions in the base language, can result in a powerful mechanism for meta-programming in an interactive manner. To support our claim, a forward-chaining hybrid system was integrated into the prototype-based programming language SELF. Experiments in the context of monitoring code, in search of "bad smells" and suggesting refactorings, show its utility as a meta-programming tool.
Lopez Paruma, Oscar Andres

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     De Meuter, Wolfgang (Vrije Universiteit Brussel, Belgium)
     Van Paesschen, Ellen (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - 751 K] 

LOZANO, Angela (Colombia)

Title: A Representation of Java Programs as Partial Graph Morphisms.
Abstract: Translator is a tool that performs a mapping from Java source code to graph transformations. These transformations are represented as double pushout production rules.
Translator was developed as an extension of GROOVE (GRaphs for Object Oriented VErification) which is oriented to develop a fully automated verification tool for object oriented programs. GROOVE is a set of tools product of a straightforward translation from the graph rewriting theory. GROOVE software (version 0.0.2) is composed by an editor that allows the creation of state graphs and production rule or transformation graphs, by a viewer that shows with a special format a production rule and by a simulator that, given an initial state graph and production rule graphs, can detect the possible matches from a production rules set against a state graph and applying one of these matches to the state graph.
The main contribution of this thesis was to represent code statements as graph transformations and to model object-oriented programs (in particular Java source code programs) into graphs whose elements do not have own identity.
Lozano, Angela

  
Welcome Institution:
     University of Twente (The Netherlands)
Advisor(s):
     Rensink, Arend (University of Twente, The Netherlands)
File(s): [pdf - 588 K] 

MACHADO, Marcelo (Brazil)

Title: Detecting Desing Defects in Object-Oriented Sofware.
Abstract: To be able to evolve, a software has to maintain good design characteristics. The main objective of this research is to define a platform to automate the detection of design defects in application developed using object-oriented programming. Based on a precise detegorazion of types of problems, we provide a suitable set of tools and techniques based on metrics, code critic and anti-patterns that are combined to detect the design problem. A prototype of the platform will be implemented to validate and assess our approach on real cases.
Machado, Marcelo

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Borne, Isabelle (Ecole des Mines de Nantes, France)
File(s):

MANHAES, Mary (Brazil)

Title: A Framework for Information Visualization.
Abstract: Information visualization is an emerging field of human computer interaction aimed improving the discovery of new phenomenon and simplifying database queries through graphical manipulations.
The research will enable the visualization system to access data stored in general purpose databases. Once loaded, the database has to be visualized by projecting actual dimensions of the database into graphical dimensions. The mapping of database information for visualization should be controlled through filters object that should be modeled and some should be implemented. Finally, once displayed, the user should be able to search for specific information by expressing queries using interactive control objects.
Manhaes, Mary

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
File(s):

MEJIAS, Boris (Chile)

Title: Applying Prototype-Based Programming Techniques for the Organization of Mobile Systems.
Abstract: Agents succeeded as mobile entities that properly solved problems on mobile systems. They can move around the network in a transparent way, and communicate with other agents by sending messages. But the relationship between agents does not have a strong structure, and big multi-agent systems become hard to maintain and to understand. The primary aim of this work is to provide a way to organize agents in mobile systems.
Objects help us to have a structured way of programming, but if we want objects moving around different address spaces, we need them to be self-supporting. When objects depends on a class, we also need to move the class everywhere the object goes, and to have a sophisticated system for type checking. We decided to use Prototype-Based Programming, a paradigm to program without classes, which has a proper way of reasoning about sharing, an important property for our purpose to organize the system.
We extend Borg, a language to implement autonomous agents in a wide area network. The extension provides methods to create prototypes that can move and be extended through the network. The objects and their extensions use distributed delegation to share behavior and state, having a clear hierarchy and structure, helping us to maintain and evolve the systems.
Mejias, Boris

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     De Meuter, Wolfgang (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - 600 K] 

MEZA, Rodrigo (Chile)

Title: Towards an Aspect for Grey-box Component Composition.
Abstract: Component-based development promotes the use of pre-built independent pieces of software to build applications called components. Software development is thus focusing on component composition, i.e., to link components to one another and to customize them. A major problem of composition is that a composition operation frequently involves manipulation of many different components and different parts of their respective structures. Black-box and white-box composition models describe restrictions on the component manipulations composition operations may perform. However, black-box models of composition frequently are rather inflexible, while manipulations based on white-box models are often too general and lack structure.
The aim of this MSc thesis is to define a structured and flexible model for component manipulations. This is achieved by means of a grey-box model for composition relying on two main ideas. First, it is based on a hierarchization of component manipulations according to their invasiveness. Second, we propose an essential step towards the treatment of composition as an aspect in the sense of Aspect-Oriented Programming: our grey-box model enables composition operations involving several components and different parts within components to be encapsulated. The proposed grey-box model is derived from and applied to three rather different component models: Sun's Enterprise JavaBeans, JavaBeans and an OO framework for program verification in Java.
Meza, Rodrigo

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Sudholt, Mario (Ecole des Mines de Nantes, France)
File(s):

MICHIELS, Isabel (Belgium)

Title: Teaching Object Technology with Intelligent Environements.
Abstract: The objective of this research project is to explore how to enhance environments for learning object technology with declarative knowledge about good object-oriented programming practice and about the learning process itself. This knowledge will allow us to infer what the student is learning and what he is not. In particular we can enrich existing object-oriented environment such as (LearninghWorks) with pedagogical rules (cast as logic predicates) that lead the leaning process.
The knowledge about the learning process of a particular student can then also be used to individualize the interaction of the environment to that student.
Michiels, Isabel

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentine)
Advisor(s):
     Rossi, Gustavo (Universidad Nacional de La Plata, Argentine)
File(s): [zip - 384 K]  [pdf - 826 K]  [ps - 6.01 MB] 

MOTELET, Olivier (France)

Title: A contextual help system for assisting OO designers in using design patterns.
Abstract: Design patterns are very useful and important tools for improving software design, but they have a complexity cost. Considering that, design patterns should be applied only when it is really necessary. This thesis is the result of a research effort and draws the basements of a contextual help system that assists OO software designers in using design patterns in a right way. Our system suggests the use of design patterns not only as limited reusable pieces of design but mainly as a design style proposal which should help the designer without limiting his creativity. Our project proposes an original structure for describing design patterns. On the base of this presentation, it introduces an advanced contextual support for evaluating the suitability of design patterns and for navigating through them towards solutions.
Motelet, Olivier

  
Welcome Institution:
     Universidade Federal do Rio de Janeiro (Brazil)
Advisor(s):
     Lima, Cabral (Universidade Federal do Rio de Janeiro, Brazil)
File(s): [pdf - 3.27 MB] 

MUñOZ, Francisca (Chile)

Title: A Logic Meta-Programming Framework for Supporting the Refactoring Process.
Abstract: The objective of this thesis is to provide automated support for recognizing design flaws in object oriented code, suggesting proper refactorings and performing automatically the ones selected by the user.
Software suffers from inevitable changes throughout the development and the maintenance phase, and this usually affects its internal structure negatively. This makes new changes difficult to implement and the code drifts away from the original design. The introduced structural disorder can be countered by applying refactorings, a kind of code transformation that improves the internal structure without affecting the behavior of the application.
There are several tools that support applying refactorings in an automated way, but little help for deciding where to apply a refactoring and which refactoring should be applied.
This thesis presents an advanced refactoring tool that provides support for the earlier phases of the refactoring process, by detecting and analyzing bad code smells in a software application, proposing appropriate refactorings that solve these smells, and letting the user decide which one to apply. This tool relies on the technique of logic meta programming, a variant of the logic paradigm that allows to reason about code at a high level of abstraction.
Logic meta programming is used for querying about code and expressing structural relations like message sends, usage of variables or inheritance relations. This allows our tool to detect a number of bad smells, most of them highly time-consuming to detect manually. When a bad smell is detected, the relevant entities are analyzed in order to propose appropriate refactorings with the necessary parameters. For effectively applying the refactorings, the tool relies on existing refactoring implementations provided by the Refactoring Browser.
The tool was implemented in SOUL, a logic meta-programming language on top of Smalltalk, and validated by detecting the bad smells for three different case studies on medium-sized object-oriented applications: The Collection hierarchy, the HotDraw framework and the SOUL application itself. Most detected bad smells indicated situations that were worthy of attention, and many of the proposed refactorings were actually useful to resolve the bad smells.
Muñoz, Francisca

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mens, Tom (Vrije Universiteit Brussel, Belgium)
     Tourwe, Tom (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - 761 K] 

NAKANISI, Yumi (Chile)

Title: Destructive Mixins in Statically-Typed Languages.
Abstract: In object-oriented languages, inheritance is the mechanism that allows a class share same behavior and state with another class allowing reusability of code of the parent class. But in practice, in most- object-oriented languages there are some cases where inheritance does not provides all the necessary features for some kind of required reusability and extra work must been done anyway.
What this work will do is to provide new languages features, where the original class is effectively replaced by the extended version, and at the same time maintaining the consistence of the code after the change. This new feature is called destructive mixins.
Nakanisi, Yumi

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     DeVolder, Kris (Vrije Universiteit Brussel, Belgium)
File(s):

NOGOSEKE, Fabiana (Brazil)

Title: Prioritization of Requirements.
Abstract: In this thesis, a process is described for prioritizing requirements in software development processes. Software development projects have to deal with many requirements at the same time. Moreover, projects are generally bounded by constraints like budget and time. To deal with this complexity, the project managers have to prioritize requirements effectively.
This thesis describes an application and assessment of a method called Analytic Hierarchy Process (AHP), which can be used to prioritize requirements in software development processes.
Although necessary, overall comparison of many requirements at the same time is a difficult task. One may compare two requirements, however, rather effectively. The main objective of the AHP method is to derive overall ranking from pair wise comparisons.
The prioritization may help in developing effective strategies for software development. In addition, stakeholders’ input in the prioritization process increases the possibility that the final product is more accurate in implementing the desired properties.
To illustrate the approach, a tool has been built. This tool imports use case diagrams from a standard CASE tool. The tool offers facilities for pair wise comparison of use case diagrams. Based on these comparisons, the tool computes the overall ranking of the requirements.
Nogoseke, Fabiana

  
Welcome Institution:
     University of Twente (The Netherlands)
Advisor(s):
     Aksit, Mehmet (University of Twente, The Netherlands)
File(s): [pdf - 717 K] 

NOGUERA, Carlos (Colombia)

Title: Compose*: A Runtime for the .Net Platform.
Abstract: The Composition Filters Model developed by the Trese group in the University of Twente is an approach to the problem of separation of concerns that extends the Object Oriented model with message filters. These filters intercept messages enter or exit the objects over which they are placed to model crosscutting concerns. In this work, an infrastructure for the runtime execution of Composition Filters is implemented in on top of Microsoft's .Net platform. This implementation takes advantage of the language independence features present in the .Net platform to offer a single Aspect framework that provides dynamic crosscutting to all languages that compile to the.Net framework.
The runtime provides support for various types of filters, as well as a mechanism for dynamic placing of the filters, a transparent message interception layer and a strategy based filter execution process.
Noguera, Carlos

  
Welcome Institution:
     University of Twente (The Netherlands)
Advisor(s):
     Bergmans, Lodewijk (University of Twente, The Netherlands)
File(s): [pdf - 552 K] 

NOLLEN, François (France)

Title: Aspect Language Modularization, Abstraction and Composition in the Reflex AOP Kernel.
Abstract: Aspect-Oriented Programming (AOP) has emerged as a programming paradigm for better modularization of software. Thanks to AOP, features that crosscut a modular software can be cleanly modularized in aspects. In this line, many languages supporting AOP have been proposed, some of them being general purpose, while others are domain-specific. Versatile kernels based on partial reflection have recently been proposed as a means to foster interoperability between aspects, allowing aspects written in different languages to be composed appropriately. This thesis is concerned with an open architecture for a modular definition of aspect languages, as well as a generic model for aspect composition.
Nollen, François

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Piquer, José (Universidad de Chile, Chile)
File(s): [pdf - 533 K] 

NUÑEZ, Angel (Chile)

Title: CONCURRENT ASPECTS
Abstract Aspect-Oriented Programming (AOP) promises the modularization of so-called crosscuting functionality in large applications. Currently, almost all approaches to AOP provide means for the description of sequential aspects that are to be applied to a sequential base program. A recent approach, Concurrent Event-based AOP (CEAOP), has been introduced, which models the concurrent application of aspects to concurrent base programs. CEAOP uses Finite State Processes (FSP) and their representation as Labeled Transition Systems (LTS) for modeling aspects, base programs and their concurrent composition, thus enabling the use of the Labeled Transition System Analyzer (LTSA) for formal property verification.
CEAOP does not provide an implementation of its concepts, restricting the study of concurrent aspects to the study of a model. The contribution of this thesis is the production of an implementation of CEAOP as a small DSAL (Domain-Specific Aspect Language), Baton, which is very close to FSP, and can be compiled into Java. As an intermediate layer, we have developed a Java library which makes it possible to associate a Java implementation to a finite state process. The compilation process consists of using the Baton program to translate both the Baton aspects and the Java base program into Java finite state processes. This translation relies on Metaborg/SDF to extend Java with Baton and Reflex to instrument the base program.
Nuñez, Angel

  
Welcome Institution:
     Ecole des Mine de Nantes (France)
Advisor(s):
     Noyé, Jacques (Ecole des Mines de Nantes, France)
File(s): [pdf - 490 Kb] 

PARRA RUEDA, Harmin (Colombia)

Title: Characterization and Detection of Concerns in Java Code.
Abstract: Many software systems are subject to continual revisions and expansions as new requirements are discovered, bugs are found, or migrations to new technologies need to take place in order to improve software quality. Many program evolution tasks involve the manipulation of source code in order to isolate and change the implementation of different concerns. However, such concerns may be scattered over the whole code because they cannot be easily modularized, they can be the result of inadequate design, the result of unanticipated changes, or they can be the result of a lack of expressiveness in the technology available to the original developer. Before performing a modification to a software system, code relating to concerns has to be carefully identified. Finding and understanding concerns scattered in source code is a difficult task that takes a large proportion of the total effort required to perform software maintenance and evolution. This thesis presents a model to characterize concerns, aimed to detect and to display an abstract view of concerns related code, easing the software comprehension and maintenance process. A prototype was developed in order to validate the proposed models and some case studies are presented.
Parra Rueda, Harmin

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Albin-Amiot, Hervé (Ecole des Mines de Nantes, France)
     Breton, Erwan (Sodifrance - L'inspiration technologique, France)
File(s): [pdf - 2.19 MB] 

PINALI, Osvaldo (Brazil)

Title: Desing Pattern Extraction for Software Documentation.
Abstract: We are investigating inference of patterns and other nontrivial information from source and compiled code, with adherence to the UML metamodel for abstract representation of programs, and as much language neutrality as possible in the discovery. Tools are common that can reverse engineer source code, but these are usually limited to a straightforward translation to a design form containing the same information, in the same abstraction level (classes, features, relationships). Software design patterns help to understand large designs, usually requiring collaborations of several types of objects, that occur frequently in software.
Pinali, Osvaldo

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Borne, Isabelle (Ecole des Mines de Nantes, France)
File(s): [pdf - 523 K] 

PIRES, Aline (Brazil)

Title: Formalization of UML using Algebraic Specifications.
Abstract: The goal of the thesis es to formalize UML using Algebraic Specifications. The motivation for this work is the assumption that many OO methods, including those from which UML is derived, suffer from a lack of a precise semantic. This can lead to confusions and different interpretations when analyzing a model.
There exist many algebraic specification languages, and, for this work, the prime languages used will be Larch Prover. The goal is to compose a semantic framework fr the static part of UML, which can be used as the basis to establish a set of transformation rules in UML model. These transformations can used to enhance and refine the models, guiding developers in forward and reverse engineering efforts. With these formalization and transformation rules, the correctness of the models can be better ensured.
A meta tool is used to support this semantic framework and transformation rules.
Pires, Aline

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Romanczuk Requile, Annya (Ecole des Mines de Nantes, France)
     Royer, Jean-Claude (Université de Nantes, France)
File(s): [pdf - 321 K] 

PONISIO, María Laura (Argentine)

Title: A Binding-Time Analysis for petitCafé.
Abstract: One of the mayor advantages of object-oriented languages is that they allow the easy construction of general software components, but this is achieved at high cost in terms of inefficiency.
We can attenuate this inefficiency adapting programs automatically to the environment where they are inserted. Partial evaluation is a program specialization technique to achieve this task, transforming a program into a more specialized version of it.Off-line partial evaluators perform as a first step the binding-time analysis, BTA, that determines which parts of it can be executed in advance and annotates them accordingly. BTA only works with the knowledge that some input values are known and some are not. Then, the analysis propagates this knowledge through the program and annotates each program piece, indicating whether the knowledge of the input value will make it possible to compute this program piece or not. Consequently, correct and precise BTA is of primary importance to perform efficient off-line partial evaluation.
The mission of this work was to lay the foundations for that design. Thus, we have modeled a simple BTA for a subset of Java that relays on constraint-based program analysis.
We have achieved the mission designing petitCafé, a subset of Java with specific object oriented features, modeling a simple BTA for petitCafé using constraints and implementing a prototype of the analysis. Our model adds precision to the analysis by considering objects as complex structures and it keeps the analysis simple by classifying them into equivalence classes. It is simple and flexible. It provides the basis for efficient implementation, facilitates the reasoning that would be no longer possible using a too complicated model and lays the foundations for the design of correct and precise BTAs for Java.
Ponisio, María Laura

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Noyé, Jacques (Ecole des Mines de Nantes, France)
File(s): [pdf - 438 K] 

PRESSO, María José (Argentine)

Title: Reflective and Metalevel Architecture in Java: from Object to Components.
Abstract: The purpose of this thesis research is to have a clear understating of the difference between a component model and an object model, and the to provide a protocol to express component composition.
The first step is, in the context of Java and the JavaBeans component model, to differentiate a object and a bean, considering a bean as the composition of an object or set of object and a set of "aspects", as events, idioms, patterns ans extra properties. The next step is to formalize the characteristics that distinguish a component from a plain object and reify them language itself.
Finally, I will study components composition rules and define a metaobject protocol to express these rules new ones, allowing to plug and play software components.
Presso, María José

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     DeVolder, Kris (Vrije Universiteit Brussel, Belgium)
     Cointe, Pierre (Ecole des Mines de Nantes, France)
File(s): [ppt - 96 K]  [zip - 386 K]  [pdf - 662 K]  [ps - 2.35 MB] 

QUIROGA, Pablo (Argentine)

Title: Feature Interaction in AOP.
Abstract:
Quiroga, Pablo

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     De Fraine, Bruno (Vrije Universiteit Brussel, Belgium)
     Vanderperren, Wim (Vrije Universiteit Brussel, Belgium)
File(s): [ppt - K]

RAMOS DE CARVALHO, Bruno (Portugal)

Title: Evaluating CORBA as a middleware for Parallel Cluster Computing.
Abstract: Parallel application programmers normally use classical communication libraries like PVM (Parallel Virtual Machine) and MPI (Message Passing Interface). They provide message passing mechanisms and basic synchronization primitives, mile barriers. With the increasing use of standard PC cluster for parallel computation, there is a need for more flexible communication and synchronization middleware.
This work is on the evaluation of CORBA as a middleware to cover communication and synchronization aspects in parallel cluster computing. A framework for parallel computing, preserving the basic PVM/MPI paradigms, will be defined and built upon CORBA. Making it similar to PVM/MPI, we intend to open the doors of the CORBA environment to PVM/MPI users. It should also turn easier the migration of legacy programs written for those platforms. The performance and the programming power of our proposal will be compared to the standard PVM-based solutions. This work will be developed on a 10 CPU Beowulf-style Linux cluster.
Ramos de Carvalho, Bruno

  
Welcome Institution:
     Pontificia Universidade Catolica do Parana (Brazil)
Advisor(s):
     Maziero, Carlos (Pontificia Universidade Catolica do Parana, Brazil)
File(s):

RIQUELME TORRES, Roberto A. (Chile)

Title: Source code mining for code duplication refactoring with formal concept analysis.
Abstract: Code duplication exists for many reasons, although it is known to be a bad practice. It may save costs on the development phase, but it surely has a higher cost of maintenance. What can we do to detect and eliminate those problems? This document shows how to use the mathematical foundation of Formal Concept Analysis to detect code duplication. Formal Concept Analysis allows us to identify concepts, or groupings of elements, that have common properties. We work with a particular kind of elements and properties: Methods containing similar Regular Parse Tree Expressions. We classify these concepts in a certain way to reveal candidates for code duplication refactorings and show them in an ordered way, so that the user can decide to apply the refactoring when needed. This work is done as an extension of the existing Delfstof framework for VisualWorks Smalltalk, which is currently being developed by researchers at CWI and UCL.
Riquelme Torres, Roberto A.

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mens, Kim (Université catholique de Louvain, Belgium)
     Tourwe, Tom (Centrum voor Wiskunde en Informatica, Belgium)
File(s): [pdf - 1.60 MB] 

RIVERA PARDO, Diego Fernando (Colombia)

Title: On Aspect-Oriented Concurrent and Distributed Patterns.
Abstract:
Rivera, Diego

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Südholt, Mario (Ecole des Mines de Nantes, France)
     Vanderperren, Wim (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - MB] 

ROMAN, Pablo (Chile)

Title: Refelctive Virtual Machine.
Abstract: This thesis aims to go further in the concept of reflection in programming languages that means know and modify the language entities by the language itself. A next step in reflection is to use the language to modify its own interpreter (Virtual Machine). The goal of this thesis is to design an experimental programming environment that is capable of describing, generating and even changing its own virtual machine. This is applicable in the next generation of distributed programs where independence of platform, communication and technology is crucial. We propose to implement these new concepts in a simple language (The Pico language from Prog Lab) and its simple virtual machine. We want to add the capability of adding new functionality to the virtual machine like new native functions.
Roman, Pablo

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Roman, Pablo (Vrije Universiteit Brussel, Belgium)
File(s):

ROMERO, Natalia (Argentine)

Title: Managing architectural reuse and Evolution with Reuse contracts.
Abstract: Although some formalisms are being developed for software architectures, little work has been done to address the problem of evolution of architecture. Nevertheless, it is important to evolve an architecture, or to reuse more general architectural descriptions to create more specific ones. Evolution conflicts may arise when two architects independently modify an architecture so that its intention changes in an unexpected way, or when changing an architecture that has already been reused. We think that reuse contracts provide a good framework to document the evolution of software architectures and detect evolution conflicts. In this theses, a general model to express software architectures will be adopted, reuse contracts will be extended to deal with the specific concepts and conflicts found in the area of software architecture, and a conflict checking tool will be built. We will use an industrial case study to validate the approach.
Romero, Natalia

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mens, Kim (Vrije Universiteit Brussel, Belgium)
File(s):

SALINAS CARO, Patricio (Chile)

Title: Adding Systemic Crosscutting and Super-Imposition to Composition Filters.
Abstract: Although Composition Filters count as one of the most powerful techniques for advanced software composition, some recent related research has pointed out the benefits of support for systemic cross-cuttings and super-imposition of behavior. Shortly, this means the ability to express certain system-wide behavior in a single module, and apply this to existing (and possibly future) components distributed over the system. Typical examples are: adding persistence, logging, resource management, etceteras to an application or system. Such features will traditionally cause the same or very similar code to be embedded and mixed with application code all over the system.
The objective of this thesis is to design and implement this new approach based on the current implementation of ComposeJ, which is an implementation of the Composition Filter model in the Java language. Existing related tools that currently support crosscutting in Java, like AspectJ or HyperJ, will be investigated as candidates to achieve this goal. To motivate this work, the thesis will show the advantages of using the Composition Filter model to support multiple concerns.
Salinas Caro, Patricio

  
Welcome Institution:
     University of Twente (The Netherlands)
Advisor(s):
     Aksit, Mehmet (University of Twente, The Netherlands)
     Bergmans, Lodewijk (University of Twente, The Netherlands)
File(s): [ppt - 304 K]  [pdf - 1.06 MB] 

SéGURA-DEVILLECHAISE, Marc (France)

Title: Portable semantic alterations in Java.
Abstract: In non-purely object-oriented languages some basic abstractions are not treated as objects. Their semantics cannot be refined using standard object-oriented techniques like polymorphism or inheritance. Metaobject protocols are a solution. However most of them are limiting the alterations to object-oriented constructions. Abstractions that are not handled as objects by the language can therefore not be altered. In the case of the Java language, there is however an important set of instructions interpreted by the virtual machine that closely match fundamental concepts of the language. By providing a mechanism to insert bytecode instructions (e.g, a method body) directly into existing bytecode, some fundamental concepts of the language could therefore be altered, although they remain hard-wired in the virtual machine.These hook insertions can be used to reify, on the client side, fundamental object-oriented concepts like: object initialization, method calls and casts for instance. This, per se, would represent a notable step forward since until now portable bytecode instrumentation tools like Javassist do not reify these concepts, or in a limited manner. Those concepts are clearly reified only in modified virtual machines (hence scarifying portability). The purpose of this thesis is to explore the feasibility and implement at least some of these ideas. An open reflective extension like Reflex can directly benefit from this work, since it will provide it with code transformation entities allowing an increased expressiveness of the meta-object protocol.
Ségura-Devillechaise, Marc

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Mateu, Luis (Universidad de Chile, Chile)
File(s): [pdf - 629 K] 

SIMMONDS, Jocelyn (Chile)

Title: Consistency Maintenance of UML Models with Description Logics.
Abstract: Nowadays, the prevailing methodology used to specify software designs is UML. This language consists of various types of diagrams, each one dedicated to a different design aspect. This variety of views, that overlap with respect to the information depicted in each, can leave the overall system design specification in an inconsistent state. Necessarily, some form of consistency checking must be performed between different UML models. This is especially true in the context of design evolution. Therefore, a means of detecting and solving inconsistencies between related UML models must be provided.
With respect to UML models, two types of consistency can be noted: consistency between models belonging to the same design version and consistency between different versions of the same model. These are known as horizontal and evolution consistency, respectively. Current UML CASE tools do not take full advantage of the relationships that exist between the different UML model elements, and, as such, provide poor support for maintaining consistency between (evolving) UML models.
By specifying consistency relationships in a formal and precise way, reasoning about model consistency will be possible. The current UML metamodel provides poor support for consistency preservation and software evolution, e.g. versions are not supported. Relationships between models cannot be established. This thesis proposes a way in which this support can be integrated in the UML metamodel, with only some minor additions.
Based on the characteristics of inconsistencies observed between UML models, a classification of inconsistencies is proposed. To be able to detect and resolve inconsistencies, both a formal specification of model consistency and a formal reasoning engine relying on this specification is needed. This is also true for design restructurings, as their detection depends on the same metamodel relationships as the inconsistencies. This thesis studies the feasibility of using the formalism of Description Logics (DL) for this purpose.
In order to determine the suitability of DL, small experiments have been carried out. Detection predicates need to be written for each inconsistency. These have then been applied to the case study prepared for the occasion. The experimental results for inconsistencies and design restructurings indicate the feasibility of approach. Finally, these predicates have been incorporated into a tool that automates the translation between UML models and logic assertions, allowing the effortless application of detection and solution predicates.
Simmonds, Jocelyn

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mens, Tom (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - 2.31 MB] 

STANDAERT, Dieter (Belgium)

Title: A Metaobject Protocol for AmbientTalk based on Mirror Methods.
Abstract: Ambient-Oriented Programming (AmOP) languages are especially designed for software development for pervasive and ambient computing. In this context, reflective abilities are highly desired to be able to create adaptive software. In this thesis, we propose a reflective architecture for ambient actors, instantiated in the AmOP language AmbientTalk. Our architecture is structured according to different levels of abstraction, distinguishing between the metalevel for regular objects and active objects. The architecture adopts at its core the concept of mirrors and mirror methods to safeguard object encapsulation even in the presence of powerful reflective facilities, such as access to the VM.
Standaert, Dieter

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Tanter, Eric (Universidad de Chile, Chile)
File(s): [pdf - 1.2 MB] 

TANG, Zukai (China)

Title: Scalable Tool Support for Software Evolution.
Abstract: Reuse contracts are a technique and formalism for documenting and managing software evolution. A prototype tool has been written to validate the ideas in different domains. But the formalism of reuse contract is weak on dealing with software evolution sequences. It mainly addresses the primitive software evolution. Nevertheless, software evolution sequences are important in modern software development since software artifacts tend to be complex and large, and software evolutions are also more complex. We often need to use evolution sequences, which consist of some primitive evolutions, to express the complex evolution situations. In order to improve the evolution efficiency, we should make use of the properties of evolution sequences sufficiently. In this dissertation, we will present a mechanism of using application conditions in reuse contracts, which can help us deal with evolution sequences in a scalable way. Based on the mechanism of application conditions, we can predefine a set of algorithms that are independent of the primitive evolutions. Using these algorithms, we can reduce the complexity and length of the evolution sequences, even detect evolution syntactic conflicts in a general way. All the algorithms do not need to be adapted when we change the set of primitive evolutions and the set of application conditions. This mechanism enhances the scalability of reuse contracts on dealing with evolution sequences.
Tang, Zukai

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Mens, Tom (Vrije Universiteit Brussel, Belgium)
File(s):

TANTER, Eric (France)

Title: Reflex: A Reflective System for Java - Application to Flexible Resource Management in Mobile Object Systems.
Abstract: Mobile computing is a growing research area in the computing community. Many research works focus on ways to achieve and evaluate strong and weak mobility, in particular with the Java programming language. However, all these approaches adopt fixed strategies for managing resources attached to migrating entities.
In this thesis, we propose to build a simple extension of Java that allows flexible resource management, enabling the programmer to easily specify and change the migration strategies to be used for each resource. Our implementation is based on reflection techniques and meta-programming. Finally, we plan to integrate our extension to some existing mobile code object systems.
Tanter, Eric

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Piquer, José (Universidad de Chile, Chile)
File(s): [zip - 339 K]  [pdf - 998 K]  [ps - 1.25 MB] 

TORRES, Lucia (Brazil)

Title: A Guideline to detect reusable components.
Abstract: The main objective of this work is to identify a guideline encouraging the detection, definition and use of reusable software components. This work characterizes the different levels of reuse in the cycle of software development, showing categories and main features of reusable components. This guideline will allow companies to have a referential of componentes that can assure the reuse.
Torres, Lucia

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Romanczuk Requile, Annya (Ecole des Mines de Nantes, France)
File(s): [pdf - 381 K] 

VALLEJOS, Jorge (Chile)

Title: Mobile Actors Supporting Reconfigurable Applications in Open Peer-to-Peer Networks.
Abstract: Mobile technology is gently beginning to seep into society. With it, new visions of computing can be realized, where users are continually surrounded with mobile and embedded computing devices. Whereas these scenarios are becoming ever more realistic, programming such devices remains notoriously difficult, due to the limited resources (in terms of memory and battery power) and volatile connections these devices can sustain between each other. This thesis will investigate code mobility to compensate for the dynamic reconfiguration of mobile networks, due to unexpected events such as device disconnections prompted by users moving about. Therefore, we propose a model for handling both device and code mobility in dynamically reconfigurable environments, such as mobile networks. In the spirit of the mobile ad-hoc networks, which are not equipped with server architectures the strong mobility mechanism performs a decentralized reconfiguration that is entirely transparent to the programmer.
Vallejos, Jorge

  
Welcome Institution:
     Vrije Universiteit Brussel (Belgium)
Advisor(s):
     Van Cutsem, Tom (Vrije Universiteit Brussel, Belgium)
     Mostinckx, Stijn (Vrije Universiteit Brussel, Belgium)
File(s): [pdf - 1.32 MB] 

VAN DE MAELE, Felix (Belgium)

Title: Towards a Scalable and Collaborative Information Integration Platform and Methodology.
Abstract:
Van de Maele, Felix

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentine)
Advisor(s):
     Meersman, Robert (Vrije Universiteit Brussel, Belgium)
     Diaz, Alicia (Universidad Nacional de La Plata, Argentine)
File(s): [pdf - MB] 

VAN HAM, Jurgen (Belgium)

Title: Implementing a Safethread Model by modifying a JVM.
Abstract: In concurrent programming, programmers face a mayor danger with threads: to leave critical sections undetected. A critical section requires careful synchronization among threads to avoid concurrent manipulation of the same data structure. It is difficult to detect all potential critical sections on a large application, these bugs are hard to find because they become apparent at random times and cannot be reproduced. A new model, called safe-threads, ensures that every concurrent access to a shared data structure will be synchronized, and is therefore safe for this major source of bugs. The subject of this thesis is to modify a Java Virtual Machine, that it will support this new model.
Van Ham, Jurgen

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Mateu, Luis (Universidad de Chile, Chile)
File(s): [zip - 243 K]  [pdf - 317 K]  [ps - 636 K] 

VANBRABANT-CATTOOR, Marc-Emile (Belgium)

Title: Data Mining e-Resources in the LEOPARD Platform.
Abstract: Repositories have a tremendous amount of data stored often making navigation or information retrieval for users a hard task to accomplish. Furthermore, repository administrators want to stay up to date with the latest usage patterns of their repositories and are looking for an easy way to extract knowledge from this data. We propose a Business Intelligent Architecture as part of the LEOPARD project, to aid the mining of data in repositories. The architecture will allow for different algorithms to be plugged in and tasks can be performed by these algorithms upon selection by the administrator via the user interface. The prototype of the Business Intelligent Architecture has been designed and implemented. It has a naive algorithm implemented as a proof-of-concept. The prototype was built on the existing agent infrastructure and agent framework developed as part of the LEOPARD project.
Vanbrabant-Cattoor, Marc-Emile

  
Welcome Institution:
     Monash University (Australia)
Advisor(s):
     Romanczuk Requile, Annya (Monash University, Australia)
     Mingins, Christine (Monash University, Australia)
     Sheard, Judy (Monash University, Australia)
File(s): [pdf - 1.05 MB] 

VANMEERT, Rob (Belgium)

Title: Executing software process viewpoints on a workflow system.
Abstract:
Vanmeert, Rob

  
Welcome Institution:
     Universidad de Los Andes (Colombia)
Advisor(s):
     Casallas, Rubby (Universidad de Los Andes, Colombia)
File(s): [pdf - MB] 

VERNAILLEN, Michael (Belgium)

Title: Reflection for Adaptable Mobile Code in Ubiquitous Computing.
Abstract: In perspective of ubiquitous computing and mobile computing, migrating entities need to be able to adapt to the state of the environment (network bandwidth, reliability, target host characteristics, etc.). In this work we show how the way migrating objects are referenced (reference, copy, etc.) can be adapted dynamically to the state of the environment.
To achieve this kind of adaptation, we use the reflective framework Reflex. Using Reflex, we can attach metaobjects to normal Java objects. Such a metaobject can trap the serialization process of its base object when it is about to migrate, and give control to other metalevel entities which then decide what migration policy (copy, reference, etc.) to use, by accessing different sources of information.
In this work, we design a metalevel library using this approach. We show how this metalevel library can transparently be plugged onto any application to dynamically adapt the way migrating parts of this application are referenced. Furthermore we design a reusable infrastructure to allow synchronization between parts of the application that migrate using the copy policy, and finally we extend this infrastructure to support the disconnect operation.
Vernaillen, Michael

  
Welcome Institution:
     Universidad de Chile (Chile)
Advisor(s):
     Piquer, José (Universidad de Chile, Chile)
File(s): [pdf - 896 K]  [zip - 1.04 MB] 

VERWAEST, Toon (Belgium)

Title: Object-Oriented Component Detection for Software Understanding.
Abstract:
Verwaest, Toon

  
Welcome Institution:
     Universidad Nacional de La Plata (Argentina)
Advisor(s):
     Arevalo, Gabriela (Universidad Nacional de La Plata, Argentina)
File(s): [pdf - MB] 

WALLET, Thomas (France)

Title: Use of Wbe-based Three Tiers Architectures: Applying Separation of Concerns to the Modelization and Implementation of a Dynamic Internet Database Interface.
Abstract: My thesis takes place in collaboration between the computer Science Department of the UENF (Universidade Estadual do Norte Fluminense) and the Sedign and Development Team of DATAPREV, which is a governmental company that manages all the data linked to Braziliam social welfare. As this team has to provide software support for DATAPREV data management, they asked me to carry out the RecInternet project. It consists in creating a contextual object-oriented interface that enables web-users to dynamically compose requests to remote databases and to dynamically organize the presentation of the corresponding data. Related to many computer sciences field (3-tier architecture, databases, dynamic interfaces, Internet technologies, hypermedia navigation...), this entire project covers important software engineering fields such as reuse of an existing project, state of the art of the new Internet-related technologies, and design, implementation and evaluation of a real-world application.
Wallet, Thomas

  
Welcome Institution:
     Universidade Federal do Rio de Janeiro (Brazil)
Advisor(s):
     Lima, Cabral (Universidade Federal do Rio de Janeiro, Brazil)
File(s): [pdf - 5.49 MB] 

WERNER, Walter (Brazil)

Title: Towards Caesar: Aspect interfaces, their Bindings and Implementations.
Abstract: Generic functionalities of applications are those concerns of the system that can be useful in many places within the same application domain, or even in other domains, playing distinct roles. Even though this kind of functionality is very common in software development, current object-oriented language technologies give only little means to deal with those functionalities.
Aspect-oriented programming has brought great advance for defining generic concerns and integrating them into existent applications by introducing the concept of aspect. However this abstraction loses object-oriented features when describing generic functionalities chiefly because in the level of the aspects and its integration into the base application goals of modularity are not completely achieved.
This thesis presents language support to the notion of aspect interfaces to improve the current technology in the context of Caesar programming language. Aspect interfaces are abstractions to help decoupling the aspect implementation from the aspect binding, as well as describing concerns as a set of abstractions that together define the functionality as a whole. In addition to that, new support is presented in order to integrate these concerns into base applications without changing their modular structure. With these new concepts introduced in the language, Caesar facilitates reuse and componentization of aspects.
By using aspect interfaces and their involved concepts, generic functionalities can be expressed as self-contained components organized in stable architectures. In this structure they communicate with the application that they get integrated into through the restricted and clearly defined aspect interface, thereby achieving goals of reusability and extendibility.
Werner, Walter

  
Welcome Institution:
     Technishe Universität Darmstadt (Germany)
Advisor(s):
     Mezini, Mira (Technishe Universität Darmstadt, Germany)
     Ostermann, Klaus (Technishe Universität Darmstadt, Germany)
File(s): [pdf - 468 K] 

WINDMULLER, James (Brazil)

Title: Mobile Agents: Patterns and Reflection.
Abstract: Mobile Agents technology integrates many diverse disciplines of computer science and is considered as a powerful concept that can be used to develop a new category of complex, distributed and dynamic application such as those enabled by the internet.
The goal is to design different patterns in order to model agent-based applications. The first phase of this research will be a practical experimentation with mobile agents using different applications followed by an illustration using a relevant example. An Agent Pattern will be proposed taking in to account all the generic mechanisms used by an agents that can be applied in a reusable design pattern.The agent pattern will be implemented in Java and illustrated by the example used before.
Windmuller, James

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Ledoux, Thomas (Ecole des Mines de Nantes, France)
File(s): [pdf - 1.24 MB] 

WURTH, David (Germany)

Title: Dynamic service Discovery across Technology Boundaries..
Abstract: Microsoft's .NET platform offers a new model for component-based development. Programs which compile into the .NET runtime are equipped with self-describing metadata, enabling dynamic object discovery and instantiation, and even the ability to create or extend and persist new types at runtime. The notion of Web Services plays a major role in the .NET application architecture. A Web Service is a programmable application logic accessible using Internet protocols, such as Hypertext Transfer Protocol (HTTP) and Extensible Markup Language (XML). Another crucial part in the .NET Web Services architecture is the Simple Object Access Protocol (SOAP).
In order for clients and servers to use other devices and services as resources, they need a standard way to discover each other. The Java-enabled way to discover other resources is through Jini. Jini's service discovery approach is, in contrast to the .NET approach, based on interfaces and mobile objects, hence using object type matching to ensure type safety. One of the key issues emerging here is that metadata management is crucial. Jini describes its services through interfaces and provides metadata in attribute objects. Whereas .NET exposes application elements as services which are described using a document- oriented approach. This is achieved by using SOAP and the Web Service Description Language (WSDL) as a means for specifying metadata.
The aim of the research project is to define a model for transparent interworking between Jini and the .NET component framework. The idea is to make .NET's Web Service features, hence its document-oriented approach, available to the Jini environment by using both reflection and metadata capabilities. To maintain some semblance of type safety a means to abstractly describe the Jini services is needed, such as the aforementioned WSDL.
The criteria by which the success will be evaluated are based on the model's ability to provide type safety and to accommodate different connection models.
Wurth, David

  
Welcome Institution:
     Monash University (Australia)
Advisor(s):
     Mingins, Christine (Monash University, Australia)
File(s): [pdf - 594 K] 

XU, Kaiye (China)

Title: Analysis and Implementation Asynchronous Component Model.
Abstract: Component-based development is the popular approach in nowaday IT industry. It gives software developer a highly modular way to integrate all the necessary components as a whole system of the specialized application. Furthermore, component could be reused for a lot of different situation since every component is designed as an independent unit with its own function. Thus this reduces much time and money on software production, and makes the emphasis about software quality more on the system design in the software life cycle. How to get an elegant and efficient component model is a core issue in the methodology to build component-based software. Meanwhile, today is Internet time. All the application must be migrated or developed from local machine to the network. One important fact of network is that it need the component to work in distributed, concurrent and heterogeneous environments. Obviously synchronous and asynchronous communication glues all the components together to obtain some intended function. Correspondingly the component model is divided into asynchronous model and synchronous model. However asynchronous model get less attention on its analysis and implementation than synchronous one in the past. According to the new programming language ProActive using asynchronous communication, my master thesis is trying to give some rules to translate the asynchronous component model to its implementation of ProActive. Moreover I give one common algorithm to check the message buffer size in asynchronous model represented by ATAG. At last I would like to discuss some interesting questions about some future work on component and asynchronous model.
Xu, Kaiye

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Royer, Jean-Claude (Ecole des Mines de Nantes, France)
File(s): [pdf - 658 K] 

ZHAO, Liang Jing (China)

Title: Patchwork.NET: Aspect-Oriented Extension of the .NET.
Abstract: Aspect-Oriented Programming (AOP) is a new programming paradigm coping with Separation of Concerns and enhancing the reusability and comprehensibility of the code. Many AOP tools extending different languages are already available and commonly used. However, there is still no any AOP extension for Microsoft .NET platform. In this dissertation, we propose an Aspect-Oriented Extension for .NET framework, Patchwork.NET. The basic concepts of AOP systems are joinpoints, pointcuts and weaver. Patchwork.NET's weaver is based upon the Debugging API of .NET Common Language Runtime, allowing dynamic weaving. This enables AOP programmers to bind or unbind their aspects to the base program at runtime. The pointcut mechanism of Patchwork.NET is relatively open, it is easy to be extended and can be customized for a particular application domain. Moreover, Patchwork.NET inherits the Multi-Language support from the .NET framework: the base program, the advice and the pointcuts can be programmed in several, potentially different, .NET compliant languages. An interesting perspective of the proposed architecture is that it is possible to weave aspects within an already woven aspect at runtime.
Zhao, Liang Jing

  
Welcome Institution:
     Ecole des Mines de Nantes (France)
Advisor(s):
     Menaud, Jean-Marc (Ecole des Mines de Nantes, France)
File(s):
EMOOSE . Program . Admissions . Campus & Accommodation . Alumni . Partners . Contact