Ilham Alloui

Automatic Package Coupling and Cycle Minimization

Object-oriented (OO) software is usually organized into subsystems using the concepts of package or module.Such modular structure helps applications to evolve when facing new requirements.However, studies show that as software evolves to meet requirements and environment changes, modularization quality degrades. To help maintainers improve the quality of software modularization we have designed and implemented a heuristic search-based approach for automatically optimizing inter-package connectivity (i.e., dependencies).In this paper, we present our approach and its underlying techniques and algorithm.We show through a case study how it enables maintainers to optimize OO package structure of source code.Our optimization approach is based on Simulated Annealing technique.

Towards A Process-Oriented Software Architecture Reconstruction Taxonomy

To maintain and understand large applications, it is crucial to know their architecture. The first problem is that unlike classes and packages, architecture is not explicitly represented in the code. The second problem is that successful applications evolve over time, so their architecture inevitably drifts. Reconstructing the architecture and checking whether it is still valid is therefore an important aid. While there is a plethora of approaches and techniques supporting architecture reconstruction, there is no comprehensive state of the art and it is often difficult to compare the approaches. This article presents a state of the art on software architecture reconstruction approaches

Package Surface Blueprints: Visually Supporting the Understanding of Package Relationships

Large object-oriented applications are structured over large number of packages. Packages are important but complex structural entities that may be difficult to understand since they play different development roles (i.e., class containers, code ownership basic structure, architectural elements...). Maintainers of large applications face the problem of understanding how packages are structured in general and how they relate to each others. In this paper, we present a compact visualization, named Package Surface Blueprint, that qualifies the relationships that a package has with its neighbours. A Package Surface Blueprint represents packages around the notion of package surfaces: groups of relationships according to the packages they refer to. We present two specific views one stressing the references made by a package and another showing the inheritance structure of a package. We applied the visualization on two large case studies: ArgoUML and Squeak.

Package Reference Fingerprint: a Rich and Compact Visualization to Understand Package Relationships

Object-oriented languages such as Java, Smalltalk, and C+ + structure their programs using packages, allowing classes to be organized into named abstractions. Maintainers of large applications need to understand how packages are structured and how they relate to each other, but this task is very complex because packages often have multiple clients and different roles (class container, code ownership...). Cohesion and coupling are still among the most used metrics, because they help identify candidate packages for restructuring; however, they do not help maintainers understand the structure and interrelationships between packages. In this paper, we present the package fingerprint, a 2D visualization of the references made to and from a package. The proposed visualization offers a semantically rich, but compact and zoomable visualization centered on packages. We focus on two views (incoming and outgoing references) that help users understand how the package under analysis is used by the system and how it uses the system. We applied these views on three large case studies: JBoss, Azure us, and ArgoUML.

Advanced Services for Process Evolution: Monitoring and Decision Support

Process support environments (PSEs) are widely used for modelling, enacting and analyzing human intensive processes. The benefits of a PSE become apparent when processes to be supported are long lived and distributed and contain heterogeneous components. Generally, such processes are subject to dynamic evolution, i.e. they have to be changed during their execution. Unfortunately, virtually none of the existing PSEs consider dynamic evolution of processes. This article explains the concepts and techniques underlying a set of components developed in the ESPRIT Project Process Instance Evolution (PIE) that support the dynamic evolution of processes. These concepts and techniques are demonstrated using a real-world scenario from the automotive industry.

The Package Blueprint: Visually analyzing and quantifying packages dependencies ☆

Large object-oriented applications are structured over many packages. Packages are important but complex structural entities that are difficult to understand since they act as containers of classes, which can have many dependencies with other classes spread over multiple packages. However to be able to take decisions (e.g., refactoring and/or assessment decisions), maintainers face the challenges of managing (sorting, grouping) the massive amount of dependencies between classes spread over multiple packages. To help maintainers, there is a need for at the same time understanding, and quantifying, dependencies between classes as well as understanding how packages as containers of such classes depend on each other. In this paper, we present a visualization, named Package Blueprint, that reveals in detail package internal structure, as well as the dependencies between an observed package and its neighbors, at both package and class levels. Package Blueprint aims at assisting maintainers in understanding package structure and dependencies, in particular when they focus on few packages and want to take refactoring decisions and/or to assess the structure of those packages. A package blueprint is a space filling matrix-based visualization, using two placement strategies that are enclosure and adjacency. Package blueprint is structured around the notion of surfaces that group classes and their dependencies by their packages (i.e., enclosure placement); whilst surfaces are placed next to their parent node which is the package under-analysis (i.e., adjacency placement). We present two views: one stressing how an observed package depends upon the rest of the system and another stressing how the system depends upon that package. To evaluate the contribution of package blueprint for understanding packages we performed an exploratory user study comparing package blueprint with an advanced IDE. The results shows that users of package blueprint are faster in analyzing and assessing package structure. The results are proved statically significant and they show that package blueprint considerably improve the experience of standard browser users.

Towards Software Architecture Physiology: Identifying Vital Components

Several architecture analysis methods are proposed in the literature for evaluating both the structure and the behavior of architectures. A parallel between humans and software systems leads to some interesting consideration on kinds of analysis that can be performed on a system architecture, such as the identification of vital element. Such identification improves the system architecture understanding and allows us to estimate to what extent, a change on some components could impact the rest of the architecture.

Approche centrée architecture pour l'évolution dynamique de systèmes d'information

Work on architecture-cenired software development has been undertaken during the past years, leading to architecture description languages with high expressive power. We focus on the impact those new approaches may have on the software evolution management, namely supporting the evolution issues at earlier development phases than the usual coding/maintenance time. Several evolution possibilities may be envisaged, depending on whether the evolution is or is not foreseen during the design phase, and on whether the evolution takes place during the software execution or not. Existing works address some of these possibilities, but mainly concern the software evolution at the implementation level. Handling the inconsistency between architecture and code becomes an issue, known as the architectural drift. In this paper we present how, by using specific language mechanisms and a dedicated virtual machine, the ArchWare languages and environment allow us to cover the identified evolution possibilities, on the svstem architecture.

Alliance: an agent-based case environment for enterprise process modelling, enactment and quantitative control

Nowadays enterprise processes are characterized by their: (a) cooperative nature; (b) geographical distribution/decentralisation; (c) permanent change. CASE environments to model and manage enterprise processes must meet these requirements.The paper presents ALLIANCE (ALgebra and Logic for Interoperable AgeNts in Cooperative Environments) framework, an agent-based CASE environment for enterprise process modelling, enactment and quantitative control. The framework originally intended to support process definition, instantiation and enactment is extended with process quantitative management support. It provides project managers with advanced fuzzy logic-based monitoring facilities, support for decision making and change control mechanisms. Its main features is that it relies on the one hand, on a goal-oriented approach for process quantitative management, and on the other hand, on inter-operable decentralized cooperative software agents for achieving goals. In our approach, both software-intensive enterprise processes and quantitative management are carried out by software agents. One important feature of such framework is its adaptivity as it provides facilities for evolution: software agents are interchangeable, they also may evolve themselves.