Coupling, code reuse and open implementation in reflective systems

Little research has been conducted in investigating the implications of employing reflection in object-oriented (OO) systems on software qualities such as coupling and reuse. In this thesis, we investigate the reflective capabilities of Java as a representative of mainstream OO languages and propose a behavioural reflection model, which complements the language's inextensible, introspective, structural reflection model. We show that reflective systems based on the proposed model support the principle of open implementation, and exhibit less coupling and a higher level of code reuse. Programming examples explain how the behaviour of such systems can be customised or adapted without changing their default behaviour or structure. We then show that the model is also applicable to distributed systems allowing for generic coding on the server side. We address the question of assessing coupling and code reuse qualities of reflective systems quantitatively. For this purpose, we define a dynamic coupling metric and a measuring tool that allows the collection of object coupling data at runtime. A case study shows that our coupling metric can be measured automatically and confirms the hypothesis about the relatively low coupling of reflective systems in comparison with equivalent systems based on the classical non-reflective programming model. As for code reuse, we define OO reuse metrics by extending a set of metrics previously developed for procedural languages. A case study is used to confirm the hypothesis that reflective systems are more reusable than non-reflective systems exhibiting the same behaviour.

[1]  E KrasnerGlenn,et al.  A cookbook for using the model-view controller user interface paradigm in Smalltalk-80 , 1988 .

[2]  Patrick Donohoe Software product lines : experience and research directions : proceedings of the First Software Product Lines Conference (SPLC1), August 28-31, 2000, Denver, Colorado, USA , 2000 .

[3]  Ralph Johnson,et al.  design patterns elements of reusable object oriented software , 2019 .

[4]  Steve Counsell,et al.  Applications of dynamic proxies in distributed environments , 2005, Softw. Pract. Exp..

[5]  Norman E. Fenton,et al.  Software Metrics: A Rigorous Approach , 1991 .

[6]  Martin Hitz,et al.  Measuring coupling and cohesion in object-oriented systems , 1995 .

[7]  Shigeru Chiba,et al.  Yet Another java.lang.Class , 1998, ECOOP Workshops.

[8]  Steve Counsell,et al.  Dynamic coupling metric: proof of concept , 2005, IEE Proc. Softw..

[9]  Sallie M. Henry,et al.  Object-oriented metrics that predict maintainability , 1993, J. Syst. Softw..

[10]  Pattie Maes,et al.  Concepts and experiments in computational reflection , 1987, OOPSLA '87.

[11]  Victor R. Basili,et al.  A Validation of Object-Oriented Design Metrics as Quality Indicators , 1996, IEEE Trans. Software Eng..

[12]  Geoffrey A. Pascoe Encapsulators: A New Software Paradigm in Smalltalk-80 , 1986, OOPSLA.

[13]  Jacques Ferber,et al.  Computational reflection in class based object-oriented languages , 1989, OOPSLA '89.

[14]  Will Tracz,et al.  Software reuse myths , 1988, SOEN.

[16]  Bertrand Meyer,et al.  Object-Oriented Software Construction, 2nd Edition , 1997 .

[17]  Martin Shepperd,et al.  Derivation and Validation of Software Metrics , 1993 .

[18]  Bjarne Stroustrup,et al.  The Design and Evolution of C , 1994 .

[19]  Gregor Kiczales,et al.  Beyond the Black Box: Open Implementation , 1996, IEEE Softw..

[20]  James Withey Investment Analysis of Software Assets for Product Lines. , 1996 .

[21]  Murray Silverstein,et al.  A Pattern Language , 1977 .

[22]  David A. Gustafson,et al.  Properties of Software Measures , 1991, Formal Aspects of Measurement.

[23]  Mark Lorenz Object-Oriented Software Metrics , 1994 .

[24]  Lionel C. Briand,et al.  Dynamic coupling measurement for object-oriented software , 2004, IEEE Transactions on Software Engineering.

[25]  Youssef Hassoun,et al.  The development of generic definitions of hyperslice packages in Hyper/J , 2003, Electron. Notes Theor. Comput. Sci..

[26]  Ron Weber,et al.  An Ontological Model of an Information System , 1990, IEEE Trans. Software Eng..

[27]  Krzysztof Czarnecki,et al.  Generative programming - methods, tools and applications , 2000 .

[28]  William F. Opdyke,et al.  Refactoring object-oriented frameworks , 1992 .

[29]  Thomas A. Cargill C-i--~ programming style , 1992 .

[30]  S. E. Keene,et al.  A programmer's guide to object-oriented programming in Common LISP , 1988 .

[31]  Daniel G. Bobrow,et al.  Book review: The Art of the MetaObject Protocol By Gregor Kiczales, Jim des Rivieres, Daniel G. and Bobrow(MIT Press, 1991) , 1991, SGAR.

[32]  Rubén Prieto-Díaz,et al.  Making software reuse work: an implementation model , 1991, SOEN.

[33]  Alan Borning,et al.  Deltatalk: An Empirically and Aesthetically Motivated Simplification of the Smalltalk-80 Language , 1987, ECOOP.

[34]  Jacques Malenfant,et al.  Reflection in logic, functional and object-oriented programming: a Short Comparative Study , 1995 .

[35]  Barbara Liskov,et al.  Data Abstraction and Hierarchy , 1987 .

[36]  Christopher Alexander,et al.  The Timeless Way of Building , 1979 .

[37]  H. D. Rombach,et al.  Towards a comprehensive framework for reuse: A reuse-enabling software evolution environment , 1988 .

[38]  Fergus Nicol,et al.  Patterns of Software: Tales from the Software Community , 1998 .

[39]  Charles W. Krueger,et al.  Software reuse , 1992, CSUR.

[40]  Balachander Krishnamurthy,et al.  An Objective Reuse Metric: Model and Methology , 1995, ESEC.

[41]  James M. Bieman,et al.  Inheritance tree shapes and reuse , 1997, Proceedings Fourth International Software Metrics Symposium.

[42]  James M. Bieman,et al.  Reuse through inheritance: a quantitative study of C++ software , 1995, SSR '95.

[43]  Lionel C. Briand,et al.  A Unified Framework for Coupling Measurement in Object-Oriented Systems , 1999, IEEE Trans. Software Eng..

[44]  Ted J. Biggerstaff,et al.  The library scaling problem and the limits of concrete component reuse , 1994, Proceedings of 1994 3rd International Conference on Software Reuse.

[45]  Brian Henderson-Sellers,et al.  Object-Oriented Metrics , 1995, TOOLS.

[46]  Premkumar T. Devanbu,et al.  An Investigation into Coupling Measures for C++ , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[47]  Gregor Kiczales,et al.  Towards a new model of abstraction in software engineering , 1991, Proceedings 1991 International Workshop on Object Orientation in Operating Systems.

[48]  Hany H. Ammar,et al.  Dynamic metrics for object oriented designs , 1999, Proceedings Sixth International Software Metrics Symposium (Cat. No.PR00403).

[49]  Rubén Prieto-Díaz,et al.  Status report: software reusability , 1993, IEEE Software.

[50]  Rachel Harrison,et al.  An Investigation into the Applicability and Validity of Object-Oriented Design Metrics , 1998, Empirical Software Engineering.

[51]  R. Prieto-Diaz,et al.  Classification of reusable modules , 1989 .

[52]  Graham Roberts,et al.  Architectural Development Pattern , 1999, EuroPLoP.

[53]  David A. Moon,et al.  The Lisp Machine manual , 1981, SGAR.

[54]  B. Henderson-Sellers A book of object-oriented knowledge: object-oriented analysis, design and implementation, a new approach to software engineering , 1992 .

[55]  A. Paepcke CLOS in Context: The Shape of the Design Space , 1993 .

[56]  James F. Power,et al.  Toward a definition of run-time object-oriented metrics , 2003 .

[57]  Andreas Paepcke Metaobject Protocols: Why We Want Them and What Else They Can Do , 1993 .

[58]  Daniel G. Bobrow,et al.  Common lisp object system specification , 1988, SIGP.

[59]  Erik Arisholm Dynamic coupling measures for object-oriented software , 2002, Proceedings Eighth IEEE Symposium on Software Metrics.

[60]  Elaine J. Weyuker,et al.  Evaluating Software Complexity Measures , 2010, IEEE Trans. Software Eng..

[61]  Carl H. Smith,et al.  On Weyuker's Axioms For Software Complexity Measures , 1991, IEEE Trans. Software Eng..

[62]  David Robson,et al.  Smalltalk-80: The Language and Its Implementation , 1983 .

[63]  Cristina V. Lopes,et al.  Open Implementation Design Guidelines , 1997, Proceedings of the (19th) International Conference on Software Engineering.

[64]  Dale R. Peterson Economics of Software Product Lines , 2003, PFE.

[65]  Steve Counsell,et al.  A dynamic runtime coupling metric for meta-level architectures , 2004, Eighth European Conference on Software Maintenance and Reengineering, 2004. CSMR 2004. Proceedings..

[66]  Bertrand Meyer,et al.  Eiffel: The Language , 1991 .

[67]  D. L. Parnas,et al.  On the criteria to be used in decomposing systems into modules , 1972, Software Pioneers.

[68]  Steve Counsell,et al.  Reusability, open implementation and Java's dynamic proxies , 2003, PPPJ.

[69]  Cristina V. Lopes,et al.  Aspect-oriented programming , 1999, ECOOP Workshops.

[70]  Brian Foote,et al.  Designing Reusable Classes , 2001 .

[71]  Shigeru Chiba,et al.  OpenJava: A Class-Based Macro System for Java , 1999, Reflection and Software Engineering.