Gabriela Arévalo

Detecting implicit collaboration patterns

A key problem during software development and maintenance is to detect and recognize recurring collaborations among software artifacts that are implicit in the code. These collaboration patterns are typically signs of applied idioms, conventions and design patterns during the development of the system, and may entail implicit contracts that should be respected during maintenance, but are not documented explicitly. We apply formal concept analysis to detect implicit collaboration patterns. Our approach generalizes Antoniol and Tonella one for detecting classical design patterns. We introduce a variation to their algorithm to reduce the computation time of the concepts, a language-independent approach for object-oriented languages, and a post-processing phase in which pattern candidates are filtered out. We identify collaboration patterns in the analyzed applications, match them against libraries of known design patterns, and establish relationships between detected patterns and their nearest neighbours.

Identifying traits with formal concept analysis

Traits are basically mixins or interfaces but with method bodies. In languages that support traits, classes are composed out of traits. There are two main advantages with traits. Firstly, decomposing existing classes into traits from which they can be recomposed improves the factoring of hierarchies. Secondly it increases the library reuse potential by providing more reusable traits. Identifying traits and decomposing class hierarchies into traits is therefore an important and challenging task to facilitate maintainability and evolution. In this paper we present how we use Formal Concept Analysis to identify traits in inheritance hierarchies. Our approach is two-staged: first we identify within a hierarchy maximal groups of methods that have a set of classes in common, second we cluster cohesive groups of methods based on method invocations as potential traits. We applied our approach on two significant hierarchies and compare our results with the manual refactorization of the same code which was done by the authors of traits.

Building abstractions in class models: formal concept analysis in a model-driven approach

Designing class models is usually an iterative process to detect how to express, for a specific domain, the adequate concepts and their relationships. During those iterations, the abstraction of concepts and relationships is an important step. In this paper, we propose to automate this abstraction process using techniques based on Formal Concept Analysis in a model-driven context. Using UML2.0 class diagrams as modeling language for class models, in this proposal we show how our model-driven approach enables parameterization, tracing and generalization to any metamodel to express class models.

Lessons learned in applying formal concept analysis to reverse engineering

A key difficulty in the maintenance and evolution of complex software systems is to recognize and understand the implicit dependencies that define contracts that must be respected by changes to the software. Formal Concept Analysis is a well-established technique for identifying groups of elements with common sets of properties. We have successfully applied FCA to complex software systems in order to automatically discover a variety of different kinds of implicit, recurring sets of dependencies amongst design artifacts. In this paper we describe our approach, outline three case studies, and draw various lessons from our experiences. In particular, we discuss how our approach is applied iteratively in order to draw the maximum benefit offered by FCA.

Performances of galois sub-hierarchy-building algorithms

The Galois Sub-hierarchy (GSH) is a polynomial-size representation of a concept lattice which has been applied to several fields, such as software engineering and linguistics. In this paper, we analyze the performances, in terms of computation time, of three GSH-building algorithms with very different algorithmic strategies: Ares, Ceres and Pluton. We use Java and C++ as implementation languages and Galicia as our development platform. Our results show that implementations in C++ are significantly faster, and that in most cases Pluton is the best algorithm.

Analysing Object-Oriented Application Frameworks Using Concept Analysis

This paper proposes to use the formal technique of Concept Analysis to analyse how methods and classes in an object-oriented inheritance hierarchy are coupled by means of the inheritance and interfaces relationships. Especially for large and complex inheritance hierarchies, we believe that a formal analysis of how behaviour is reused can provide insight in how the hierarchy was built and the different relationships among the classes. To perform this analysis, we use behavioural information provided by the self sends and super sends made in each class of the hierarchy. The proposed technique allows us to identify weak spots in the inheritance hierarchy that may be improved, and to serve as guidelines for extending or customising an object-oriented application framework. As a first step, this paper reports on an initial experiment with the Magnitude hierarchy in the Smalltalk programming language.

Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis

Context: Inheritance is the cornerstone of object-oriented development, supporting conceptual modeling, subtype polymorphism and software reuse. But inheritance can be used in subtle ways that make complex systems hard to understand and extend, due to the presence of implicit dependencies in the inheritance hierarchy. Objective: Although these dependencies often specify well-known schemas (i.e., recurrent design or coding patterns, such as hook and template methods), new unanticipated dependency schemas arise in practice, and can consequently be hard to recognize and detect. Thus, a developer making changes or extensions to an object-oriented system needs to understand these implicit contracts defined by the dependencies between a class and its subclasses, or risk that seemingly innocuous changes break them. Method: To tackle this problem, we have developed an approach based on Formal Concept Analysis. Our Formal Concept Analysis based-Reverse Engineering methodology (FoCARE) identifies undocumented hierarchical dependencies in a hierarchy by taking into account the existing structure and behavior of classes and subclasses. Results: We validate our approach by applying it to a large and non-trivial case study, yielding a catalog of hierarchy schemas, each one composed of a set of dependencies over methods and attributes in a class hierarchy. We show how the discovered dependency schemas can be used not only to identify good design practices, but also to expose bad smells in design, thereby helping developers in initial reengineering phases to develop a first mental model of a system. Although some of the identified schemas are already documented in existing literature, with our approach based on Formal Concept Analysis (FCA), we are also able to identify previously unidentified schemas. Conclusions: FCA is an effective tool because it is an ideal classification mining tool to identify commonalities between software artifacts, and usually these commonalities reveal known and unknown characteristics of the software artifacts. We also show that once a catalog of useful schemas stabilizes after several runs of FoCARE, the added cost of FCA is no longer needed.

Lessons Learned in Applying Formal Concept Analysis

Towards Generic Pattern Mining.- Conceptual Exploration of Semantic Mirrors.- Towards a Formal Concept Analysis Approach to Exploring Communities on the World Wide Web.- Automatic Selection of Noun Phrases as Document Descriptors in an FCA-Based Information Retrieval System.- Combining Spatial and Lattice-Based Information Landscapes.- Explaining the Structure of FrameNet with Concept Lattices.- Lessons Learned in Applying Formal Concept Analysis to Reverse Engineering.- Navigation Spaces for the Conceptual Analysis of Software Structure.- Restructuring Help Systems Using Formal Concept Analysis.- An Application of FCA to the Analysis of Aeronautical Incidents.- Characterization and Armstrong Relations for Degenerate Multivalued Dependencies Using Formal Concept Analysis.- Formal Concept Analysis Constrained by Attribute-Dependency Formulas.- On Computing the Minimal Generator Family for Concept Lattices and Icebergs.- Efficiently Computing a Linear Extension of the Sub-hierarchy of a Concept Lattice.- A Generic Algorithm for Generating Closed Sets of a Binary Relation.- Uncovering and Reducing Hidden Combinatorics in Guigues-Duquenne Bases.- A Parallel Algorithm for Lattice Construction.- Using Intermediate Representation Systems to Interact with Concept Lattices.- Crisply Generated Fuzzy Concepts.- Triadic Concept Graphs and Their Conceptual Contents.- Alpha Galois Lattices: An Overview.- A Finite State Model for On-Line Analytical Processing in Triadic Contexts.- Complete Subalgebras of Semiconcept Algebras and Protoconcept Algebras.- Coherence Networks of Concept Lattices: The Basic Theorem.- Turing Machine Representation in Temporal Concept Analysis.- Protoconceptual Contents and Implications.- Planarity of Lattices.- Bialgebraic Contexts for Distributive Lattices - Revisited.- Which Concept Lattices Are Pseudocomplemented?.

XRay views: understanding the internals of classes

Understanding the internal workings of classes is a key prerequisite to maintaining an object-oriented software system. Unfortunately, classical editing and browsing tools offer mainly linear and textual views of classes and their implementation. These views fail to expose the semantic relationships between the internal parts of a class. We propose X-Ray views - a technique based on concept analysis - which reveal the internal relationships between groups of methods and attributes of a class. X-Ray views are composed of elementary collaborations between attributes and methods, and help the engineer to build a mental model of how a class works internally. In this paper we present X-Ray views, and illustrate the approach by applying it on the Smalltalk class UIBuilder.

Formal Concept Analysis-Based Service Classification to Dynamically Build Efficient Software Component Directories

Component directories index components by the services they offer thus enabling us to rapidly access them. Component directories are also the cornerstone of dynamic component assembly evolution when components fail or when new functionalities have to be added to meet new requirements. This work targets semi-automatic evolution processes. It states the theoretical basis of on-the-fly construction of component directories using formal concept analysis based on the syntactic description of the services that components require or provide. In these directories, components are more clearly organised and new abstract and highly reusable component external descriptions suggested. Moreover, this organisation speeds up both automatic component assembly and automatic component substitution.