Radu Marinescu

Measuring the number of authors and establishing the main developer of the files belonging to a software system are very important activities. Currently there are different approaches for measuring these characteristics. In this paper we compare the results provided by a well-known approach against an approach that, to the best of our knowledge, was not previously employed. The comparison is performed against a suite of nine popular open source systems and reveals that in many cases there are significant differences among the provided results.

Summary form only given. Assessing and improving quality is paramount in every engineering discipline. Software engineering, however, is not considered a classical engineering activity for several reasons, such as intrinsic complexity and lack of rigor. In general, if a software system is delivering the expected functionality, only in few cases people see the need to analyze the internals. This tutorial is aimed to offer a pragmatic approach to analyzing the quality of software systems. On the one hand, it will offer a brief theoretical background on detecting quality problems by using and combining metrics, and by providing visual evidence of the state of affairs in the system. On the other hand, as analyzing real systems requires adequate tool support, the tutorial will offer an overview of the problems that occur in using such tools and provide a practical demonstration of using state-of-the-art tools on a real case study.

Presents the welcome message from the conference proceedings.

Design flaws are those characteristics of design entities (e.g., methods, classes) which make them harder to maintain. Existing studies show that classes revealing particular design flaws are more change and defect prone than the other classes. Since various collaborations are found among the instances of classes, classes are not isolated within the source code of object-oriented systems. In this paper we investigate if classes using classes revealing design flaws are more defect prone than classes which do not use classes revealing design flaws. We detect four design flaws in three releases of Eclipse and investigate the relation between classes that use/do not use flawed classes and defects. The results show that classes that use flawed classes are defect prone and this does not depend on the number of the used flawed classes. This findings show a new type of correlation between design flaws and defects, bringing evidence related to an increased likelihood of exhibiting defects for classes that use classes revealing design flaws. Based on the provided evidence, practitioners are advised once again about the negative impact design flaws have at a source code level.

When aiming to understand object-oriented distributed applications, reverse engineering processes can model the systems by representing the aspects specific to the object orientation. While these representations provide means for in-depth analysis of various characteristics of the applications, such approaches may ignore their most important traits, specifically those related to the distribution itself. This paper describes the representation of object-oriented distributed systems we have developed to support our reverse engineering approach, and presents the rationale behind the model. The model is built so that the process focuses on the most important aspects of this class of applications, therefore efficiently achieving system understanding by narrowing the search for relevant knowledge. We have applied the process on a couple of case studies, and evaluated the systems by instantiating the model to drive the assessment of the distribution-related characteristics.

Distributed applications address the needs of heterogeneous networks of human activities, therefore they must consist of balanced, relatively autonomous intercommunicating components. Unfortunately, real-world systems do often not follow these requirements, or their architecture gets degraded in time by many ad-hoc changes. Consequently, these systems have to go frequently through the costly and oftentimes manually-performed operation of restructuring services and their inter-connections. This paper introduces a restructuring technique for distributed systems that supports an architect in performing a cost-aware analysis of various restructuring scenarios. The technique enables the engineer/architect to explore and evaluate the impact of the restructuring process at a fine-grained level, by providing both a forecast of the restructuring outcome, and the projected cost of the process itself. The approach described is mainly based on a suite of novel coupling metrics, a new algorithm that builds the forecast of the restructured architecture, and a formula for computing the cost. The approach was successfully applied on a commercial distributed framework implemented using RMI and in this paper we summarize the findings and the practical experience. Although the technique was developed for the specific case of distributed systems, we are confident that it can be easily generalized to a larger class of applications.

AND/OR search spaces accommodate advanced algorithmic schemes for graphical models which can exploit the structure of the model. We extend and evaluate the depth-first and best-first AND/OR search algorithms to solving 0-1 Integer Linear Programs (0-1 ILP) within this framework. We also include a class of dynamic variable ordering heuristics while exploring an AND/OR search tree for 0-1 ILPs. We demonstrate the effectiveness of these search algorithms on a variety of benchmarks, including real-world combinatorial auctions, random uncapacitated warehouse location problems and MAX-SAT instances.

Despite many advances in program comprehension, polymorphism and inheritance are still the cause of many misunderstandings in object-oriented code. In this paper, we present a suite of such concrete, recurrent patterns where particular ways of using inheritance and polymorphism can easily mislead developers and maintainers during software understanding activities. We define these as comprehension pitfalls. Furthermore, the paper describes a metric-based approach aimed to automatically detect such situations in code. The experimental results presented in this paper, based on three medium-sized systems, indicate that the identified comprehension pitfalls and the approach used to detect them are a promising support for maintenance.

The software industry is increasingly facing the issues of understanding and maintaining a particular type of software systems, namely distributed systems. While these systems are usually implemented in an object-oriented fashion, they raise very specific, and technology-dependent, understandability and quality assessment challenges. In this paper we present a novel approach for understanding a distributed system, by analyzing the structure of its source code and identifying the design fragments that contribute to those specific features that use or depend on the distributed communication infrastructure. By applying the approach on a couple of real-world Java/RMl distributed systems, we show that it provides reliable means for capturing both an overview of the systems' distributed architecture, and a detailed understanding of the impact of the distributed features on the entire system (including the local features).