Abstract-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.

ership basic structure, architectural elements...). Packages provide or require services. They can play core roles or Large object-oriented applications are structured over contain accessory code features. Maintainers of large applilarge number ofpackages. Packages are important but comcations face the problem of understanding how packages are plex structural entities that may be difficult to understand structured in general and how packages are in relation with since they play different development roles (i.e., class coneach others in their provider/consumer roles. This problem tainers, code ownership basic structure, architectural elewas experienced first-hand by the first author while preparing ments...). Maintainers of large applicationsface the problem the 3.9 release of Squeak, a large open-source Smalltalk [8].of understanding how packages are structured in general In addition, approaches that support application remodularand how they relate to each others. In this paper, we present ization [1, 20, 22] succeed in producing alternative views for a compact visualization, named Package Surface Blueprint, system refactorings, but proposed changes remain difficult that qualifies the relationships that a package has with its to understand and assess. There is a good support for the neighbours. A Package Surface Blueprint represents packalgorithmic parts but little support to understand their results.ages around the notion ofpackage surfaces: groups of relaHence it is difficult to assess the multiple solutions. tionships according to the packages they refer to. We present Several previous works provide information on packages two specific views one stressing the references made by a and their relationships, by visualizing software artifacts, metpackage and another showing the inheritance structure of rics, their structure or their evolution [6, 7, 10, 19, 23, 28]. a package. We applied the visualization on two large case However, while these approaches are valuable, they fall short studies: Argo UML and Squeak.of providing a fine-grained view of packages that would help This paper makes heavy use of colors in the figures. Please understanding the package shapes (the number of classes it obtain and read an online (colored) version of this paper to better defines, the inheritance relationships of the internal classes, how the internal class inherit from external ones...) and help identifying their roles within an application. In this paper, we propose Package Surface Blueprint, a IIntroduction compact visualization revealing package structure and relationships. A package blueprint is structured around the concept of surface, which represents the relationships beTo cope with the complexity of large software systems, tween the observed package and its provider packages. The applications are structured in subsystems or packages. It Package Surface Blueprint reveals the overall size and inis now frequent to have large object-oriented applications ternal complexity of a package, as well as its relation with structured ...

No abstract

Context: Object-oriented languages such as Java, Smalltalk, and C++ structure their programs using packages. Maintainers of large systems need to understand how packages relate to each other, but this task is complex because packages often have multiple clients and play different roles (class container, code ownership. . . ). Several approaches have been proposed, among which the use of cohesion and coupling metrics. Such metrics help identify candidate packages for restructuring; however, they do not help maintainers actually understand the structure and interrelationships between packages.Objectives: In this paper, we use pre-attentive processing as the basis for package visualization and see to what extent it could be used in package understanding.Method: 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 views 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.Results: We applied these views on four large systems: Squeak, JBoss, Azureus, and ArgoUML. We obtained several interesting results, among which, the identification of a set of recurring visual patterns that help maintainers: (a) more easily identify the role of and the way a package is used within the system (e.g., the package under analysis provides a set of layered services), and, (b) detect either problematic situations (e.g., a single package that groups together a large number of basic services) or opportunities for better package restructuring (e.g., removing cyclic dependencies among packages). The visualization generally scaled well and the detection of different patterns was always possible.Conclusion: The proposed visualizations and patterns proved to be useful in understanding and maintaining the different systems we addressed. To generalize to other contexts and systems, a real user study is required.

With the increasing use of new technologies such as Communicating Objects (COT) and the Internet of Things (IoT) in our daily life (connected objects, mobile devices, etc.), designing Intelligent Adaptive Distributed software Systems (DIASs) has become an important research issue. Human face the problem of mastering the complexity and sophistication of such systems as those require an important cognitive load for end-users who usually are not expert. Starting from the principle that it is to technology-based systems to adapt to endusers and not the reverse, we address the issue of how to help developers design and produce such systems. We then propose WOF, an object oriented Framework founded on the concept of Wise Object (WO), a metaphor to refer to human introspection and learning capabilities. To make systems able to learn by themselves, we designed introspection, monitoring and analysis software mechanisms such that WOs can learn and construct their own knowledge. We then define a WO as a software-based entity able to learn by itself on itself (i.e. on services it is intended to provide) and also on the others (i.e. the way others use its services). A WO is seen as an avatar of either a physical or a logical object (e.g. device / software component). In this paper, we introduce the main requirements for DIASs as well as the design principles of WOF. We detail the WOF conceptual architecture and the Java implementation we built for it. To provide application developers with relevant support, we designed WOF with the minimum intrusion in the application source code. Adaptation and distribution related mechanisms defined in WOF can be inherited by application classes. In our Java implementation of WOF, object classes produced by a developer inherit the behavior of Wise Object (WO) class. An instantiated system is a Wise Object System (WOS) composed of WOs that interact through an event bus. In the first version of WOF, a WO was able to use introspection and monitoring built-in mechanisms to construct knowledge on: (a) services it is intended to render; (b) the usage done of its services. In the current version, we integrated an event-based WO simulator and a set of Analyzer classes to provide a WO with the possibility to use different analysis models and methods on its data. Our major goal is that a WO can be able to identify common usage of its services and to detect unusual usage. We use the metaphor of emotions to refer to unusual behavior (stress, surprise, etc.). We show in the paper a first experiment based on a statistical analysis method founded on stationary processes to identify usual/unusual behavior.