Tony Cahill

Fine-Grained Software Metrics in Practice

Modularity is one of the key features of the Object- Oriented (00) paradigm. Low coupling and high cohesion help to achieve good modularity. Inheritance is one of the core concepts of the 00 paradigm which facilitates modularity. Previous research has shown that the use of the friend construct as a coupling mechanism in C+ + software is extensive. However, measures of the friend construct are scarse in comparison with measures of inheritance. In addition, these existing measures are coarse-grained, in spite of the widespread use of the friend mechanism. In this paper, a set of software metrics are proposed that measure the actual use of the friend construct, inheritance and other forms of coupling. These metrics are based on the interactions for which each coupling mechanism is necessary and sufficient. Previous work only considered the declaration of a relationship between classes. The software metrics introduced are empirically assessed using the LEDA software system. Our results indicate that the friend mechanism is used to a very limited extent to access hidden methods in classes. However, access to hidden attributes is more common.

A friend in need is a friend indeed [software metrics and friend functions]

Previous research has highlighted the extensive use of the C++ friend construct in both library-based and application-based systems. However, existing software metrics do not concentrate on measuring friendship accurately, a surprising omission given the debate friendship has caused in the object-oriented community. In this paper, a number of software metrics, that measure the extent to which friend class relationships are actually used in systems, are defined. These metrics are based on the interactions for which the friend construct is necessary, as well as the direction of this association between classes. Our results, in applying these metrics to the top 100 downloaded systems from sourceforge.net, indicate that up to 66% of friend class relationships in systems are redundant. Elsewhere, friend function declarations would have been more appropriate in many cases. In addition, it has been shown that friendship-based coupling contributes significantly to the high coupling of friend classes for only 25% of the systems studied.

An empirical study of the use of friends in C++ software

A commonly held belief is that the friend construct in C++ is a violation of encapsulation. However, little empirical analysis of its use has taken place to provide evidence to support this claim. This paper presents a study, which assesses the design implications of including friendship in a system. A number of hypotheses are investigated based on previous work in this area by Counsell and Newson (2000). Our initial findings suggest that classes declared as friends are coupling hotspots, that the more friends a class has the more protected and private members it will contain and that friendship is not used to access inherited protected members.

Untangling the World-Wide Web

While, for years, the Intemet has been used to make information resources available, until relatively recently its users have been forced to interact with it through a set of difficult-to-use protocols such as FTP (File Transfer Protocol) [PR85]. Furthermore, extensive knowledge of obscure command-line interfaces, addressing schemes and file types was often required. However, recent years have seen an increase in sophisticated and user-friendly Intemet information systems. These include the WAIS (Wide Area Information Service) document server protocol, the menubased Gopher protocol and the hypertext-based World-Wide Web [Ber?32].

A replicated and refined empirical study of the use of friends in C++ software

The friend mechanism is widely used in C++ software even though the potential benefits of its use are disputed and little is known about when, where and why it is employed in practice. Furthermore, there is limited empirical analysis of its impact in object-oriented software, with only one study (Counsell and Newson, 2000) reported at journal level. This paper aims to add to the empirical evidence of friendships impact by replicating Counsell and Newson (2000)s original study. The studys design is refined to improve the construct validity of the evaluation and a larger cohort of systems is used to improve the generalisability of the results. The findings suggest that classes involved in friendship are coupling hotspots and that there is no link between inheritance and friendship, contrary to the findings presented in Counsell and Newson (2000). The findings also suggest that the use of friends in a class is independent of the number of hidden members in a class.

Applying Meyer's taxonomy to object-oriented software systems

Inheritance is one of the core concepts in object-orientation. There has been much discussion and disagreement as to the correct uses of the inheritance mechanism in the literature. The classification of B. Meyer (1996) seems to be the most comprehensive for the identification of appropriate uses of inheritance. While it seems that this taxonomy has been validated by its author, in the design and development of software, it does not seem to have been validated against existing systems. We attempt, in the first instance, to move towards this validation by attempting to define a method whereby the inheritance relationships in software systems can be classified into individual categories in Meyers taxonomy. Subsequently it also provides some insight on how inheritance is used in such systems.

Measuring the impact of friends on the internal attributes of software systems

Differing views have been expressed on the appropriateness of the friend construct in the design and implementation of object-oriented software in C++. However, little empirical analysis of its usage in the development of systems has taken place. This paper describes an empirical study of the top 100 most downloaded open-source software systems from sourceforge.net, to assess the design implications of the use of the friend construct. On a larger cohort of systems our results provide further evidence that classes declared as friends are coupling hotspots. Our findings also indicate that class size does not seem to have the confounding effect on this relationship that has been suggested in previous research. In addition, there seems to be no indication that friendship is used as an alternative to inheritance although a small number of systems seem to use friendship as an alternative to multiple inheritance and vice versa.

Towards a canonical specification of document structures

Syntax + 1/0 r % Concrete Syntax 4 + Concr.te 1/,0

Construct specific coupling measurement for C++ software

Studies which consider the extent to which the encapsulation of a class is weakened by direct access to its hidden members (such as through the use of the friend construct in C++) are scarce, and those that do exist are based on metric suites where the enabling mechanism of the coupling is ignored. This can lead to conclusions of limited construct validity where incorrect causes of coupling are suggested. In this paper a suite of software metrics which measure the amount of coupling enabled by different C++ programming language constructs (such as friendship and inheritance) are proposed. The metrics presented are based on a formal data model which can be easily adapted for other OO languages. This formal approach removes the scope for ambiguity in the metric definitions. These metrics provide a more accurate reflection of the causative agents of coupling in Object Oriented Systems and their utility is illustrated in an empirical study towards the end of the paper.

Documents are programs

Theavailability ofWYSIWYG word-pmcessingsp terns has enabled relatively unskilled individuals to produce documents with very impressive visual effects. The rapid feedback associated with WYSIWYGdito&tashelped peopletolearnquickly the effect of various features and exploxe the many features available. Unfortunately, many have come to believe that this is all that is required to produce large complex documents.