Identifying code duplication in large multi-platform software systems is a challenging problem. This is due to a variety of reasons including the presence of high-level programming languages and structures interleaved with hardware-dependent low-level resources and assembler code, the use of GUI-based configuration scripts generating commands to compile the system, and the extremely high number of possible different configurations. This paper studies the extent and the evolution of code duplications in the Linux kernel. Linux is a large, multi-platform software system; it is based on the Open Source concept, and so there are no obstacles in discussing its implementation. In addition, it is decidedly too large to be examined manually: the current Linux kernel release (2.4.18) is about three million LOCs. Nineteen releases, from 2.4.0 to 2.4.18, were processed and analyzed, identifying code duplication among Linux subsystems by means of a metric-based approach. The obtained results support the hypothesis that the Linux system does not contain a relevant fraction of code duplication. Furthermore, code duplication tends to remain stable across releases, thus suggesting a fairly stable structure, evolving smoothly without any evidence of degradation.

http://www.antoniol.net/wp-content/papercite-data/pdf/2002/1s20s0950584902001234main.pdf

Analyzing cloning evolution in the Linux kernel

As large systems evolve, their architectural integrity tends to decay. Reverse engineering tools, such as PBS [7, 19], Rigi [15], and Acacia [5], can be used to acquire an understanding of a system’s “as-built” architecture and in so doing regain control over the system. A problem that has impeded the widespread adoption of reverse engineering tools is the tight coupling of their subtools, including source code “fact” extractors, visualization engines, and querying mechanisms; this coupling has made it difficult, for example, for users to employ alternative extractors that might have different strengths or understand different source languages. The TAXFORM project has sought to investigate how different reverse engineering tools can be integrated into a single framework by providing mappings to and from common data schemas for program “facts” [2]. In this paper, we describe how we successfully integrated the Acacia C and C++ fact extractors into the PBS system, and how we were then able to create software architecture models for two large software systems: the Mozilla web browser (over two million lines of C++ and C) and the VIM text editor (over 160,000 lines of C).

http://maveric0.uwaterloo.ca/~migod/papers/2000/coset00.pdf

Secrets from the Monster: Extracting Mozilla’s Software Architecture

The paper presents extensions to Bell Canada source code quality assessment suite (DATRIX tm) for handling Java language systems Such extensions are based on source code object metrics, including Java interface metrics, which are presented and explained in detail The assessment suite helps to evaluate the quality of medium-large software systems identifying parts of the system which have unusual characteristics The paper also studies and reports the occurrence of clones in medium-large Java software systems Clone presence affects quality since it increases a system size and often leads to higher maintenance costs The clone identification process uses Java specific metrics to determine similarities between methods throughout a system The results obtained from experiments with software evaluation and clone detection techniques, on over 500 KLOC of Java source code, are presented

Extending software quality assessment techniques to Java systems

The increased popularity of the object-oriented paradigm has also increased the interest in object-oriented reengineering. First of all, object-oriented software systems suffer from similar maintainability problems as traditional procedural systems, displaying the need for reengineering techniques tailored to deal with object- oriented code. Secondly, the increased importance of iterative development processes make reengineering techniques valuable in forward engineering, and thus for all paradigms that software is developed in. Reengineering requires tool support to deal with the large amounts of information and the wide variety of tasks to be performed. An important consideration in building tool environments for reengineering is what information must be provided and how this information is modelled. Design choices have a considerable impact not only on the ability to support reengineering tasks, but also on issues such as scalability and tool interoperability. Several metamodels exist that model software for the purposes of reengineering. However, they generally lack a discussion of the relevance of information for reengineering and the trade-offs of modeling alternatives. This thesis presents FAMIX, a language-independent metamodel for modelling object-oriented software for reengineering purposes.We discuss the exact contents of the metamodel, including its relevance for reengineering and how the metamodel supports the different object-oriented languages through its language- independent core. We also discuss the infrastructural design decisions of FAMIX by placing it into a design space for infrastructural aspects of reengineering repositories and metamodels. The design space presents multiple interdependent aspects, their design alternatives and howthese impact issues such as scalability, extensibility and information exchange. We validate the ability of FAMIXto support reengineering on a language-independent level in twoways. First, we present Moose, a reengineering tool environment with a repository based on FAMIX. Moose serves as a foundation for multiple reengineering tools and has been applied to reverse engineer several large industrial case studies. Secondly,we define a set of fifteen low-level refactorings in terms of the information available in FAMIX. Refactoring requires sufficient, complete and 100 correct information as well as a clear interpretation of the supported languages in the language-independent core of the metamodel, in order to correctly perform transformations on the language-specific code level. As such the refactorings provide an in-depth validation of the language independence of FAMIX.

/pdf/modeling-object-oriented-software-for-reverse-engineering-qyu0983gyb.pdf

Modeling Object-Oriented Software for Reverse Engineering and Refactoring

In our experience the implementation of software systems frequently does not conform very closely to the planned architecture. For this reason we decided to implement source code architecture conformance checking support for Sotograph, our software analysis environment. Besides providing a conformance check for a single version of a system, Sotograph supports also trend analysis. I.e., the investigation of the evolution of a software system and the changes in architecture violations between a number of versions.

Sotograph - A Pragmatic Approach to Source Code Architecture Conformance Checking

This paper presents the results of an empirical study. The study aims at evaluating the ability to understand the coherence between design documents that describe the layered architecture of large scale systems, and the actual structure of the software source file organization. A clear set of objectives to be addressed for achieving a good understanding of a layered architecture is defined. The objectives are focused on identifying the interfaces between layers, in terms of cross-layer file dependencies. An analysis framework for achieving these objectives is proposed. The framework is applied to analyze the actual software architecture of 6 subsequent releases of a 15MLoc telecommunications product. Results of that experiment show that the framework can provide much insight on the actual implementation of a system with a layered architecture.

A. Le Bon

Papers

An analysis framework for understanding layered software architectures