Youssef Hassoun

Extracting refactoring trends from open-source software and a possible solution to the 'related refactoring' conundrum

Refactoring, as a software engineering discipline has emerged over recent years to become an important aspect of maintaining software. Refactoring refers to the restructuring of software according to specific mechanics and principles. In this paper, we describe a tool that allows refactoring data across multiple versions of seven open-source software systems to be collected. The tool automates the identification of refactorings as program transformations between consecutive software releases. The same tool thus allowed an empirical analysis of software development across versions from the perspective of those transformations. We describe results for the systems analysed and point to key conclusions from our analysis. In particular, we investigate a problematic empirical question as to whether certain refactorings are related, i.e., they cannot be undertaken in isolation without other refactorings being undertaken in parallel. In this context, we focus specifically on the four most common refactorings identified by the tool from three of the open-source systems and use a dependency graph to inform conclusions about the empirical data extracted by the tool. An interesting result relating to some common refactorings is described.

A dynamic runtime coupling metric for meta-level architectures

The extent of coupling in an object-oriented system has implications for its quality in terms of software maintenance. In turn, the extent of reuse in a software system also has implications for the maintainability of that system. One important feature of reflective systems is their dynamic behaviour. In such systems, objects exchange coupling interactions to a larger degree than corresponding static systems providing the same functionality. In this paper, we look at object coupling as it evolves during program execution and propose a measure which takes object interactions into account. The measure can be used to compare systems built on meta-level architectures with systems having no reflective features yet, at the same time, exhibiting the same interface.

The Effectiveness of Refactoring, Based on a Compatibility Testing Taxonomy and a Dependency Graph

In this paper, we describe and then appraise a testing taxonomy proposed by van Deursen and Moonen (VD&M) based on the post-refactoring repeatability of tests. Four categories of refactoring are identified by VD&M ranging from semantic-preserving to incompatible, where, for the former, no new tests are required and for the latter, a completely new test set has to be developed. In our appraisal of the taxonomy, we heavily stress the need for the inter-dependence of the refactoring categories to be considered when making refactoring decisions and we base that need on a refactoring dependency graph developed as part of the research. We demonstrate that while incompatible refactorings may be harmful and time-consuming from a testing perspective, semantic-preserving refactorings can have equally unpleasant hidden ramifications despite their advantages. In fact, refactorings which fall into neither category have the most interesting properties. We support our results with empirical refactoring data drawn from seven Java open-source systems (OSS) and from the same analysis form a tentative categorization of code smells

Dynamic coupling metric: proof of concept

Most object-oriented coupling measures proposed in the literature deal with coupling at the static class level. Measuring dynamic object coupling however gives potential for greater insight into system structure and comparison of the architectural aspects of different systems. In previous work, a dynamic coupling metric (DCM) was introduced and validated theoretically. The authors investigate an empirical validation of this metric. A tool was developed to collect dynamic coupling data represented by message exchanges between objects at runtime; two system models with different architectural characteristics providing the same functionality were then considered. Empirical validation of the metric showed it to be a useful vehicle for comparing the runtime coupling characteristics of software systems. Results also showed that for examples covering various types of couplings, object-oriented (OO) reflective systems separating the base level from the meta-level exhibited significantly less coupling when compared with corresponding systems with a traditional OO (single-level) architecture.

Applications of dynamic proxies in distributed environments

In object‐oriented programming (OOP), proxies are entities that act as an intermediary between client objects and target objects. Dynamic proxies can be used to construct distributed systems that support the open implementation approach and promote code reuse. The OO paradigm supports code reuse through various ways including inheritance, polymorphism and aggregation. In this paper, we adopt a definition of software reuse restricted to reuse of code components and address the question of constructing distributed systems based on dynamic proxies. Different networking techniques and programming paradigms such as Javas Remote Method Invocation (RMI), the Common Object Request Broker Architecture (CORBA) and Java Servlets are used to implement the distributed client/server architecture. Copyright

Understanding the complexity of refactoring in software systems: a tool-based approach

The majority of information systems these days engender a high level of complexity through the extent of possible inputs to testing, required processing and consequent outputs. In fact, complexity permeates every level of this model for an information system. Complexity thus has a direct effect on the extent to which a system needs to be tested, through those inputs. Complexity also inhibits the ease with which a system can be modified since more time needs to be devoted to assessment of change complexity and resulting tests. Reduction of complexity is the goal of every developer when initially developing a system and, as importantly, after the system has been developed and inevitable changes are made. In this paper, we analyse an automated technique for extracting the typical changes (or refactorings as we have labelled them) made to various Java systems over different versions of its lifetime. Our goal is to identify areas of change where complexity can be examined more thoroughly and aid thus given to the developer when maintaining systems. A generic tool was developed specifically for this task and the results showed new and promising insights into the way systems behave as they evolve. In particular, the complex refactorings are relatively rare compared with more simple refactorings.

The development of generic definitions of hyperslice packages in Hyper/J

Abstract In this paper we investigate the notion of reusability of aspect definitions. We discuss the development of generic aspects in Hyper/J and compare it with the AspectJ approach. In doing that, we follow the design principle of “developing with hyperslice packages” and we show that hyperspace structure, concern mapping, hyperslice definitions and merging stategies exhibit well-defined patterns. An approach to constructing and merging generic aspects with base core concerns in Hyper/J is presented.