Visualizing and Interacting with Concept Hierarchies

Concept Hierarchies and Formal Concept Analysis are theoretically well grounded and largely experimented methods. They rely on line diagrams called Galois lattices for visualizing and analysing object-attribute sets. Galois lattices are visually seducing and conceptually rich for experts. However they present important drawbacks due to their concept oriented overall structure: analysing what they show is difficult for non experts, navigation is cumbersome, interaction is poor, and scalability is a deep bottleneck for visual interpretation even for experts. In this paper we introduce semantic probes as a means to overcome many of these problems and extend usability and application possibilities of traditional FCA visualization methods. Semantic probes are visual user centred objects which extract and organize reduced Galois sub-hierarchies. They are simpler, clearer, and they provide a better navigation support through a rich set of interaction possibilities. Since probe driven sub-hierarchies are limited to users focus, scalability is under control and interpretation is facilitated. After some successful experiments, several applications are being developed with the remaining problem of finding a compromise between simplicity and conceptual expressivity

Performances of Galois Sub-hierarchy-building Algorithms

LNAI est une "Sublibrary de LNCS"International audienceThe Galois Sub-hierarchy (GSH) is a polynomial-size repre- sentation 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 imple- mentation 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

Refactorings of Design Defects using Relational Concept Analysis

Software engineers often need to identify and correct design defects, ıe} recurring design problems that hinder development and maintenance\ud by making programs harder to comprehend and--or evolve. While detection\ud of design defects is an actively researched area, their correction---mainly\ud a manual and time-consuming activity --- is yet to be extensively\ud investigated for automation. In this paper, we propose an automated\ud approach for suggesting defect-correcting refactorings using relational\ud concept analysis (RCA). The added value of RCA consists in exploiting\ud the links between formal objects which abound in a software re-engineering\ud context. We validated our approach on instances of the <span class='textit'></span>Blob\ud design defect taken from four different open-source programs

On automatic class insertion with overloading

Also published in Proceedings of the 11th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications (OOPSLA)International audienceSeveral algorithms [Cas92, MS89, Run92, DDHL94a, DDHL95, GMM95] have been proposed to automatically insert a class into an inheritance hierarchy. But actual hierarchies all include overriden and overloaded properties that these algorithms handle either very partially or not at all. Partially handled means handled provided there is a separate given function f able to compare overloaded properties [DDHL95, GMM95].In this paper, we describe a new version of our algorithm (named Ares) which handles automatic class insertion more efficiently using such a function f. Although impossible to fully define, this function can be computed for a number of well defined cases of overloading and overriding. We give a classification of such cases and describe the computation process for a well-defined set of nontrivial cases.The algorithm preserves these important properties:- preservation of the maximal factorization of properties- preservation of the underlying structure (Galois lattice) of the input hierarchy- conservation of relevant classes of the input hierarchy with their properties

Product Family Design Knowledge Representation, Aggregation, Reuse, and Analysis

A flexible information model for systematic development and deployment of product families during all phases of the product realization process is crucial for product-oriented organizations. In current practice, information captured while designing products in a family is often incomplete, unstructured, and is mostly proprietary in nature, making it difficult to index, search, refine, reuse, distribute, browse, aggregate, and analyze knowledge across heterogeneous organizational information systems. To this end, we propose a flexible knowledge management framework to capture, reorganize, and convert both linguistic and parametric product family design information into a unified network, which is called a networked bill of material (NBOM) using formal concept analysis (FCA); encode the NBOM as a cyclic, labeled graph using the Web Ontology Language (OWL) that designers can use to explore, search, and aggregate design information across different phases of product design as well as across multiple products in a product family; and analyze the set of products in a product family based on both linguistic and parametric information. As part of the knowledge management framework, a PostgreSQL database schema has been formulated to serve as a central design repository of product design knowledge, capable of housing the instances of the NBOM. Ontologies encoding the NBOM are utilized as a metalayer in the database schema to connect the design artifacts as part of a graph structure. Representing product families by preconceived common ontologies shows promise in promoting component sharing, and assisting designers search, explore, and analyze linguistic and parametric product family design information. An example involving a family of seven one-time-use cameras with different functions that satisfy a variety of customer needs is presented to demonstrate the implementation of the proposed framework

Generating a Catalog of Unanticipated Schemas in Class Hierarchies using Formal Concept Analysis

International audienceContext: 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 FoCARE methodology (Formal Concept Analysis based-Reverse Engineering) identifies undocumented hi- erarchical 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

Semantics-Based Change-Merging of Abstract Data Types

Maintaining any software is difficult. Whenever an evolutionary change is made to the base version of a program and the new version of the program is created, changes made to the base version of the software must be made to the new version. The answer is to build the software initially with the knowledge that it will change and that the base version will evolve. In other words, change-merging of software is a possible solution. All the work in this area has been done on program integration, change-merging of PSDL programs and software prototypes. The present work explores the possibility of combining the results of two independent updates of an abstract data type into a merged version that is both correct and safe. This report describes a developing theory for semantics-based change-merging of abstract data types