Quality driven Object-Oriented Software Remodularization – Cutter

Software systems, and in particular, Object-Oriented systems are models of the real world that manipulate representations of its entities through models of its processes. Software systems however suffer of two important issues: first, the world changes continuously and imposes to constantly revise the model itself; second, because details and multiple abstraction levels result in a high level of complexity, completely analyzing real software systems is impractical. For example, the Windows operating system consists of more than 60 millions lines of code (500,000 pages printeddouble-face, about 16 times the Encyclopedia Universalis). Different programming paradigms have been invented to cope with changes: late-binding, the cornerstone of object-oriented programming, is a typical illustration. Nowadays large object-oriented applications suffer from evolution problems and often require to be restructured or remodularized for example to fit memory constraints or different business cases.

Whereas software (re-)modularization is a relatively old research field in the context of C or Cobol, it is still really important and requires innovative approaches to deal with the complexity of modern systems developed in OOP languages. The mismatch between current practices and the challenges software companies are facing is due to: (1) the complexity of the manipulated concepts (subsystems, packages, classes, class hierarchies, late-binding, various import relationships....) as well as (2) the use of one type of algorithms (clustering) and one kind of system representation.

CUTTER addresses these issues by recognizing and accepting the complexity and multi-faceted nature of software remodularization, through developing, combining, and evaluating new techniques for analyzing and modularizing code. The innovation of CUTTER is to:
- combine different package decomposition techniques (graph decomposition, Formal Concept Analysis, program visualization, etc.);
- support different levels of abstractions (system, packages, classes) ;
- be directed by the quality of the resulting remodularisation and take into account expert input.

Several package decomposition techniques that will be used are: algorithmic approaches for facing to graph decomposition complexity (polynomial-time approximation algorithms, heuristics, and exacts methods), Formal Concept Analysis (FCA) algorithms, statistical clustering algorithms, and visualization based algorithms. Each of these techniques has already been used in software (re-) modularization, however, taken individually they failed to give satisfaction, offering results that are difficult to understand by software maintainers, or do not fit experts' views of the systems.

The results will include: (i) a better understanding of how to best model software systems and modules for software remodularization, considering the intended users (software maintainers); (ii) a better understanding of the strengths and weaknesses of graph algorithms, FCA, clustering algorithms, and visualizations as package decomposition techniques; (iii) new package decomposition methods combining the four techniques; (iv) new class restructuration techniques and (v) practical tools implementing these results.

Project management will be led by the team RMoD-INRIA. CUTTER will use an iterative and incremental approach allowing the two teams RMoD-INRIA and D’OC/APR-LIRMM to integrate other's advancements and profit from them. We plan to hold three workshops per year with all partners. Communication will be fostered by the use of concrete case studies to learn from, assess and steer the project results. To share results and analyses developed through the project, CUTTER will use a common source code model and format (a meta-model). The leader of each team knows each other personally and they enjoy working together, so the interaction will be dealt with efficiently.