James Power - Recent Publications

See also: Entries in DBLP, ACM Author Profile, Google Scholar

[93] Brian A. Malloy and James F. Power. Quantifying the transition from Python 2 to 3: An empirical study of Python applications. In ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, Toronto, Canada, 9-10 November 2017. [ bib | .pdf ]
Python is one of the most popular modern programming languages. In 2008 its authors introduced a new version of the language, Python 3.0, that was not backward compatible with Python 2, initiating a transitional phase for Python software developers. The study described in this paper investigates the degree to which Python software developers are making the transition from Python 2 to Python 3. We have developed a Python compliance analyser, PyComply, and have assembled a large corpus of Python applications. We use PyComply to measure and quantify the degree to which Python 3 features are being used, as well as the rate and context of their adoption. In fact, Python software developers are not exploiting the new features and advantages of Python 3, but rather are choosing to retain backward compatibility with Python 2. Python developers are confining themselves to a language subset, governed by the diminishing intersection of Python 2, which is not under development, and Python 3, which is under development with new features being introduced as the language continues to evolve.

[92] Marie Farrell, Rosemary Monahan, and James F. Power. Specification clones: An empirical study of the structure of Event-B specifications. In Software Engineering and Formal Methods, volume 10469 of Lecture Notes in Computer Science, pages 152--167, 4--8 September 2017. [ bib | DOI | .pdf ]
In this paper we present an empirical study of formal specifications written in the Event-B language. Our study is exploratory, since it is the first study of its kind, and we formulate metrics for Event-B specifications which quantify the diversity of such specifications in practice. We pay particular attention to refinement as this is one of the most notable features of Event-B. However, Event-B is less well-equipped with other standardised modularisation constructs, and we investigate the impact of this by detecting and analysing specification clones at different levels. We describe our algorithm used to identify clones at the machine, context and event level, and present results from an analysis of a large corpus of Event-B specifications. Our study contributes to furthering research into the area of metrics and modularisation in Event-B.

[91] Marie Farrell, Rosemary Monahan, and James F. Power. Combining Event-B and CSP: An institution theoretic approach to interoperability. In International Conference on Formal Engineering Methods, Xi'an, China, 13-17 November 2017. [ bib | .pdf ]
n this paper we present a formal framework designed to facilitate interoperability between the Event-B specification language and the process algebra CSP. Our previous work used the theory of institutions to provide a mathematically sound framework for Event-B, and this enables interoperability with CSP, which has already been incorporated into the institutional framework. This paper outlines a comorphism relationship between the institutions for Event-B and CSP, leveraging existing tool-chains to facilitate verification. We compare our work to the combined formalism Event-B|CSP and use a supporting example to illustrate the benefits of our approach.

[90] Andrew Healy, Rosemary Monahan, and James F. Power. Predicting SMT solver performance for software verification. In 3rd Workshop on Formal Integrated Development Environment, volume 240 of Electronic Proceedings in Theoretical Computer Science, pages 20--37, Limassol, Cyprus, November 8 2016. [ bib | DOI | .pdf ]
The Why3 IDE and verification system facilitates the use of a wide range of Satisfiability Modulo Theories (SMT) solvers through a driver-based architecture. We present Where4: a portfolio-based approach to discharge Why3 proof obligations. We use data analysis and machine learning techniques on static metrics derived from program source code. Our approach benefits software engineers by providing a single utility to delegate proof obligations to the solvers most likely to return a useful result. It does this in a time-efficient way using existing Why3 and solver installations - without requiring low-level knowledge about SMT solver operation from the user.

[89] Marie Farrell, Rosemary Monahan, and James F. Power. Providing a semantics and modularisation constructs for Event-B using institutions. In 23rd International Workshop on Algebraic Development Techniques, Gregynog, Wales, September 21-24 2016. [ bib | .pdf ]
[88] Zheng Cheng, Rosemary Monahan, and James F. Power. Formalised EMFTVM bytecode language for sound verification of model transformations. Journal of Software and Systems Modeling, pages 1--29, 2016. [ bib | DOI | .pdf ]
Model Driven Engineering is an effective approach for addressing the full life cycle of software development. Model transformation is widely acknowl- edged as one of its central ingredients. With the increasing complexity of model transformations, it is urgent to develop verification tools that prevent incorrect transformations from generating faulty models. However, the development of sound verification tools is a non-trivial task, due to unimplementable or erroneous execution semantics encoded for the target model transformation language. In this work, we develop a formalisation for the EMFTVM bytecode language by using the Boogie intermediate verification language. It ensures the model transformation language has an implementable execution semantics by reliably prototyping the implementation of the model transformation language. It also ensures the absence of erroneous execution semantics encoded for the target model transformation language by using a translation validation approach.

[87] Marie Farrell, Rosemary Monahan, and James F. Power. Using the theory of institutions to integrate software models via refinement. In PhD Symposium at iFM'16 on Formal Methods: Algorithms, Tools and Applications, Reykjavik, Iceland, June 5 2016. [ bib ]
[86] Andrew Healy, Rosemary Monahan, and James F. Power. Evaluating the use of a general-purpose benchmark suite for domain-specific SMT-solving. In 31st ACM Symposium on Applied Computing, pages 1558--1561, Pisa, Italy, April 4-8 2016. [ bib | DOI | .pdf ]
Benchmark suites are an important resource in validating performance requirements for software. However, general-purpose suites may be unsuitable for domain-specific purposes, and may provide an incorrect indication of the software performance. This paper uses SMT-solvers (Satisfiability Modulo Theories) as a case-study. Taking deductive software verification as a specific application domain for SMT-solvers, we present an approach to quantifying the difference between general-purpose and domain-specific benchmark suites. We show that workload-based clustering of benchmark programs increases the specificity of features tested by the suite compared to the inherent hierarchy of a general-purpose suite.

[85] Andrew Healy, Rosemary Monahan, and James F. Power. Evaluating SMT solvers for software verification. In 32nd British Colloquium of Theoretical Computer Science, Queens University, Belfast, Northern Ireland, March 22-24 2016. [ bib ]
[84] Marie Farrell, Rosemary Monahan, and James F. Power. A logical framework for integrating software models via refinement. In 32nd British Colloquium of Theoretical Computer Science, Queens University, Belfast, Northern Ireland, March 22-24 2016. [ bib ]
[83] Andrew Healy, Rosemary Monahan, and James Power. Characterising the workload of SMT solvers for program verification. In 22nd Workshop on Automated Reasoning, pages 17--18, Birmingham, UK, April 9-10 2015. [ bib ]
[82] Zheng Cheng, Rosemary Monahan, and James F. Power. Verifying SimpleGT transformations using an intermediate verification language. In 4th International Workshop on the Verification Of Model Transformations, pages 12--19, L'Aquila, Italy, July 2015. [ bib | .pdf ]
[81] Zheng Cheng, Rosemary Monahan, and James F. Power. A sound execution semantics for ATL via translation validation. In 8th International Conference on Model Transformation, pages 133--148, L'Aquila, Italy, July 20-21 2015. [ bib | DOI ]
In this work we present a translation validation approach to encode a sound execution semantics for the ATL specification. Based on our sound encoding, the goal is to reliably verify the ATL specification against the specified OCL contracts. To demonstrate our approach, we have developed the VeriATL verification system using the Boogie2 intermediate verification language, which in turn provides access to the Z3 theorem prover. Our system automatically encodes the execution semantics of each ATL specification (as it appears in the ATL matched rules) into the intermediate verification language. Then, to ensure the soundness of the encoding, we verify that it faithfully represents the runtime behaviour of its corresponding compiled implementation in terms of bytecode instructions for the ATL virtual machine. The experiments demonstrate the feasibility of our approach. They also illustrate how to automatically verify an ATL specification against specified OCL contracts.

[80] Aidan Mooney, Joseph Duffin, Thomas Naughton, Rosemary Monahan, James Power, and Phil Maguire. PACT: An initiative to introduce computational thinking in to second level education. In International Conference on Engaging Pedagogy, Athlone, Ireland, December 5 2014. [ bib | http | .pdf ]
PACT is a partnership between researchers in the Department of Computer Science at Maynooth University and teachers at selected post-primary schools around Ireland. Starting in September 2013, seven Irish secondary schools took part in a pilot study, delivering material prepared by the PACT team to Transition Year students. Three areas of Computer Science were identified as being key to delivering a successful course in computational thinking, namely, programming, algorithms and computability. An overview of the PACT module is provided, as well as analysis of the feedback obtained from students and teachers involved in delivering the initial pilot.

[79] James F. Power. An early completion algorithm: Thue's 1914 paper on the transformation of symbol sequences. In 10th Conference on Computability in Europe, pages 343--346, Budapest, Hungary, June 23-27 2014. [ bib | DOI | .pdf ]
References to Thue's 1914 paper on string transformation systems are based mainly on a small section of that work defining Thue systems. A closer study of the remaining parts of that paper highlight a number of important themes in the history of computing: the transition from algebra to formal language theory, the analysis of the "computational power" (in a pre-1936 sense) of rules, and the development of algorithms to generate rule-sets.

[78] Diarmuid P. O'Donoghue, James Power, Sian O'Briain, Feng Dong, Aidan Mooney, Donny Hurley, Yalemisew Abgaz, and Charles Markham. Can a computationally creative system create itself? Creative artefacts and creative processes. In International Conference on Computational Creativity, pages 146--155, Ljubljana, Slovenia, June 10-13 2014. [ bib | .pdf ]
This paper begins by briefly looking at two of the dominant perspectives on computational creativity; focusing on the creative artefacts and the creative processes respectively. We briefly describe two projects; one focused on (artistic) creative artefacts the other on a (scientific) creative process, to highlight some similarities and differences in approach. We then look at a 2-dimensional model of Learning Objectives that uses independent axes of knowledge and (cognitive) processes. This educational framework is then used to cast artefact and process perspectives into a common framework, opening up new possibilities for discussing and comparing creativity between them. Finally, arising from our model of creative processes, we propose a new and broad 4-level hierarchy of computational creativity, which asserts that the highest level of computational creativity involves processes whose creativity is comparable to that of the originating process itself.

[77] James F. Power. Exploring Thue's 1914 paper on the transformation of strings according to given rules. In International Conference on the History and Philosophy of Computing, Paris, France, Oct 28-31 2013. [ bib | .pdf ]
Rarely has any paper in the history of computing been given such a prestigious introduction as that given to Axel Thue's paper by Emil Post in 1947: "Alonzo Church suggested to the writer that a certain problem of Thue might be proved unsolvable ...". However, only the first two pages of Thue's paper are directly relevant to Post's proof, and, in this abstract, I hope to shed some light on the remaining part, and to advocate its relevance for the history of computing.

[76] Hao Wu, Rosemary Monahan, and James F. Power. Exploiting attributed type graphs to generate metamodel instances using an SMT solver. In 7th International Symposium on Theoretical Aspects of Software Engineering, pages 175--182, July 1-3 2013. [ bib | DOI | .pdf ]
In this paper we present an approach to generating instances of metamodels using a Satisfiability Modulo Theories (SMT) solver as a back-end engine. Our goal is to automatically translate a metamodel and its invariants into SMT formulas which can be investigated for satisfiability by an external SMT solver, with each satisfying assignment for SMT formulas interpreted as an instance of the original metamodel. Our automated translation works by interpreting a metamodel as a bounded Attributed Type Graph with Inheritance (ATGI) and then deriving a finite universe of all bounded attribute graphs typed over this bounded ATGI. The graph acts as an intermediate representation which we then translate into SMT formulas. The full translation process, from metamodels to SMT formulas, and then from SMT instances back to metamodel instances, has been successfully automated in our tool, with the results showing the feasibility of this approach.

[75] Zheng Cheng, Rosemary Monahan, and James F. Power. A simple complexity measurement for software verification and software testing. In International Workshop on Comparative Empirical Evaluation of Reasoning Systems, volume 873 of CEUR Workshop Proceedings, pages 28--31, Manchester, UK, June 30 2012. [ bib | .pdf | .pdf ]
In this paper, we used a simple metric (i.e. Lines of Code) to measure the complexity involved in software verification and software testing. The goal is then, to argue for software verification over software testing, and motivate a discussion of how to reduce the complexity in- volved in software verification. We propose to reduce this complexity by translating the software to a simple intermediate representation which can be verified using an efficient verifier, such as Boogie.

[74] Keith Ó Dúlaigh, James F. Power, and Peter J. Clarke. Measurement of Exception-Handling Code: An Exploratory Study. In 5th International Workshop on Exception Handling, pages 55--61, Zurich, Switzerland, June 9 2012. [ bib | DOI | .pdf ]
This paper presents some preliminary results from an empirical study of 12 Java applications from the Qualitas corpus. We measure the quantity and distribution of exception- handling constructs, and study their change as the systems evolve through several versions.

[73] Peter J. Clarke, James F. Power, Djuradj Babich, and Tariq M. King. A Testing Strategy for Abstract Classes. Software Testing, Verification and Reliability, 22(3):147--169, 2012. [ bib | DOI | .pdf ]
This paper presents a structured approach that supports the testing of features in abstract classes, paying particular attention to ensuring that the features tested are those defined in the abstract class. Two empirical studies are performed on a suite of large Java programs and the results presented. The first study analyzes the role of abstract classes from a testing perspective. The second study investigates the impact of the testing strategy on the programs in this suite to demonstrate its feasibility and to comment on the pragmatics of its use.

[72] Djuradj Babich, Peter J. Clarke, James F. Power, and B. M. Golam Kibria. Using a Class Abstraction Technique to Predict Faults in OO Classes: A case study through six releases of the Eclipse JDT. In ACM Symposium On Applied Computing, pages 1419--1424, TaiChung, Taiwan, March 21-25 2011. [ bib | DOI | .pdf ]
In this paper, we propose an innovative suite of metrics based on a class abstraction that uses a taxonomy for OO classes (CAT) to capture aspects of software complexity through combinations of class characteristics. We empirically validate their ability to predict fault prone classes using fault data for six versions of the Java-based open-source Eclipse Integrated Development Environment. We conclude that this proposed CAT metric suite, even though it treats classes in groups rather than individually, is as effective as the traditional Chidamber and Kemerer metrics in identifying fault-prone classes.

[71] Thomas Whelan, Susan Bergin, and James F. Power. Teaching Discrete Structures: A systematic review of the literature. In ACM Technical Symposium on Computer Science Education, pages 275--280, Dallas, Texas, USA, March 9-12 2011. [ bib | DOI | .pdf ]
This survey paper reviews a large sample of publications on the teaching of discrete structures and discrete mathematics in computer science curricula. The approach is systematic, in that a structured search of electronic resources has been conducted, and the results are presented and quantitatively analysed. A number of broad themes in discrete structures education are identified relating to course content, teaching strategies and the means of evaluating the success of a course.

[70] Hao Wu, Rosemary Monahan, and James F. Power. Test case generation for programming language metamodels. In Doctoral Symposium of the 3rd International Conference on Software Language Engineering, Eindhoven, Netherlands, October 11 2010. [ bib | .pdf ]
One of the central themes in software language engineering is the specification of programming languages, and domain-specific languages, using a metamodel. One problem associated with the use of programming language metamodels, and metamodels in general, is determining whether or not they are correct. In this context, the question addressed by our research is: given a programming language metamodel, how can we generate an appropriate test suite to show that it is valid?

[69] Hao Wu, Rosemary Monahan, and James F. Power. Using ATL in a tool-chain to calculate coverage data for UML class diagrams. In 2nd International Workshop on Model Transformation with ATL, pages 60--64, Malaga, Spain, June 30 2010. [ bib | .pdf ]
In this paper we describe the use of ATL as part of a tool chain that calculates coverage measures for UML class diagrams. The tool chains uses the USE tool as a parser and validator for UML diagrams, and represents the diagrams internally using the EMF framework.

[68] Jacqueline A. McQuillan and James F. Power. White-Box Coverage Criteria for Model Transformations. In 1st International Workshop on Model Transformation with ATL, pages 63--77, Nantes, France, July 8-9 2009. [ bib | .pdf ]
Model transformations are core to MDE, and one of the key aspects for all model transformations is that they are validated. In this paper we develop an approach to testing model transformations based on white-box coverage measures of the transformations. To demonstrate the use of this approach we apply it to some examples from the ATL metamodel zoo.

[67] Markus Aleksy, Vasco Amaral, Ralf Gitzel, James F. Power, and John Waldron. Foreword to the special issue on principles and practices of programming in Java. Science of Computer Programming, 74(5-6):259--260, March 2009. [ bib | DOI ]

[66] Jonathan Lambert and James F. Power. Platform Independent Timing of Java Virtual Machine Bytecode Instructions. Electronic Notes in Theoretical Computer Science, 220(3):97--113, 12 December 2008. [ bib | DOI | .pdf ]
The accurate measurement of the execution time of Java bytecode is one factor that is important in order to estimate the total execution time of a Java application running on a Java Virtual Machine. In this paper we document the difficulties and solutions for the accurate timing of Java bytecode. We also identify trends across the execution times recorded for all imperative Java bytecodes. These trends would suggest that knowing the execution times of a small subset of the Java bytecode instructions would be sufficient to model the execution times of the remainder. We first review a statistical approach for achieving high precision timing results for Java bytecode using low precision timers and then present a more suitable technique using homogeneous bytecode sequences for recording such information. We finally compare instruction execution times acquired using this platform independent technique against execution times recorded using the read time stamp counter assembly instruction. In particular our results show the existence of a strong linear correlation between both techniques.

[65] Mark Hennessy and James F. Power. Analysing the effectiveness of rule-coverage as a reduction criterion for test suites of grammar-based software. Empirical Software Engineering, 13(4):343--368, August 2008. [ bib | DOI ]
The term grammar-based software describes software whose input can be specified by a context-free grammar. This grammar may occur explicitly in the software, in the form of an input specification to a parser generator, or implicitly, in the form of a hand-written parser. Grammar-based software includes not only programming language compilers, but also tools for program analysis, reverse engineering, software metrics and documentation generation. Hence, ensuring their completeness and correctness is a vital prerequisite for their use. In this paper we propose a strategy for the construction of test suites for grammar based software, and illustrate this strategy using the ISO C++ grammar. We use the concept of grammar-rule coverage as a pivot for the reduction of an implementation-based test suite, and demonstrate a significant decrease in the size of this suite. The effectiveness of this reduced test suite is compared to the original test suite with respect to code coverage and more importantly, fault detection. This work greatly expands upon previous work in this area and utilises large scale mutation testing to compare the effectiveness of grammar-rule coverage to that of statement coverage as a reduction criterion for test suites of grammar-based software. This work finds that when grammar rule coverage is used as the sole criterion for reducing test suites of grammar based software, the fault detection capability of that reduced test suite is greatly diminished when compared to other coverage criteria such as statement coverage.

[64] Jacqueline A. McQuillan and James F. Power. A Metamodel for the Measurement of Object-Oriented Systems: An Analysis using Alloy. In IEEE International Conference on Software Testing Verification and Validation, pages 288--297, Lillehammer, Norway, April 9-11 2008. [ bib | DOI | .pdf ]
This paper presents a MOF-compliant metamodel for calculating software metrics and demonstrates how it is used to generate a metrics tool that calculates coupling and cohesion metrics. We also describe a systematic approach to the analysis of MOF-compliant metamodels and illustrate the approach using the presented metamodel. In this approach, we express the metamodel using UML and OCL and harness existing automated tools in a framework that generates a Java implementation and an Alloy specification of the metamodel, and use this both to examine the metamodel constraints, and to generate instantiations of the metamodel. Moreover, we describe how the approach can be used to generate test data for any software based on a MOF-compliant metamodel. We extend our framework to support this approach and use it to generate a test suite for the metrics calculation tool that is based on our metamodel.

[63] Markus Aleksy, Ralf Gitzel, John Waldron, and James F. Power. PPPJ 2006 special issue - foreword. Science of Computer Programming, 70(2-3):87--88, February 2008. [ bib | DOI ]
This issue of Science of Computer Programming is devoted to selected papers from the International Conference on Principles and Practices of Programming in Java (PPPJ) 2006, held in Mannheim, Germany.

[62] Nicholas A. Kraft, Brian A. Malloy, and James F. Power. A tool chain for reverse engineering C++ applications. Science of Computer Programming, 69(1-3):3--13, 1 December 2007. [ bib | DOI ]
We describe a tool chain that enables experimentation and study of real C++ applications. Our tool chain enables reverse engineering and program analysis by exploiting gcc, and thus accepts any C++ application that can be analyzed by the C++ parser and front end of gcc. Our current test suite consists of large, open-source applications with diverse problem domains, including language processing and gaming. Our tool chain is designed using a GXL-based pipe-filter architecture; therefore, the individual applications and libraries that constitute our tool chain each provide a point of access. The preferred point of access is the g4api Application Programming Interface (API), which is located at the end of the chain. g4api provides access to information about the C++ program under study, including information about declarations, such as classes (including template instantiations); namespaces; functions; and variables, statements, and some expressions. Access to the information is via either a pointer to the global namespace, or a list interface.

[61] Peter J. Clarke, Djuradj Babich, Tariq M. King, and James F. Power. Intra-Class Testing of Abstract Class Features. In 18th IEEE International Symposium on Software Reliability Engineering, pages 191--200, Trollhattan, Sweden, 5-9 November 2007. [ bib | DOI | .pdf ]
This paper presents a structured approach that supports the testing of features in abstract classes. Core to the approach is a series of static analysis steps that build a comprehensive view of the inter-class dependencies in the system under test. We then leveraged this information to define a test order for the methods in an abstract class that minimizes the number of stubs required during testing, and clearly identifies the required functionality of these stubs. Our approach is based on a comprehensive taxonomy of object-oriented classes that provides a framework for our analysis. First we describe the algorithms to calculate the inter-class dependencies and the test-order that minimizes stub creation. Then we give an overview of our tool, AbstractTestJ that implements our approach by generating a test order for the methods in an abstract Java class. Finally, we harness this tool to provide an analysis of 12 substantial Java applications that demonstrates both the feasibility of our approach and the importance of this technique.

[60] Steven Kearney and James F. Power. REM4j - A framework for measuring the reverse engineering capability of UML CASE tools. In 19th International Conference on Software Engineering and Knowledge Engineering, pages 209--214, Boston, USA, 9-11 July 2007. [ bib | .pdf ]
Reverse Engineering is becoming increasingly important in the software development world today as many organizations are battling to understand and maintain old legacy systems. Today's software engineers have inherited these legacy systems which they may know little about yet have to maintain, extend and improve. Currently there is no framework or strategy that an organisation can use to determine which UML CASE tool to use. This paper sets down such a framework, to allow organisations to base their tool choice on this reliable framework. We present the REM4j tool, an automated tool, for benchmarking UML CASE tools, we then use REM4j to carry out one such evaluation with eleven UML CASE tools. This framework allows us to reach a conclusion as to which is the most accurate and reliable UML CASE tool.

[59] Jacqueline A. McQuillan and James F. Power. On the application of software metrics to UML models. In Models in Software Engineering - Workshops and Symposia at MoDELS 2006, Reports and Revised Selected Papers, pages 217-- 226, Springer Lecture Notes in Computer Science, Vol. 4364 2007. [ bib | DOI | .pdf ]
In this position paper we discuss a number of issues relating to model metrics, with particular emphasis on metrics for UML models. Our discussion is presented as a series of nine observations where we examine some of the existing work on applying metrics to UML models, present some of our own work in this area, and specify some topics for future research that we regard as important. Furthermore, we identify three categories of challeges for model metrics and describe how our nine observations can be partitioned into these categories.

[58] Nicholas A. Kraft, Brian A. Malloy, and James F. Power. An Infrastructure to Support Interoperability in Reverse Engineering. Information and Software Technology, 49(3):292--307, March 2007. [ bib | DOI | .pdf ]
The reverse engineering community has recognized the importance of interoperability, the cooperation of two or more systems to enable the exchange and utilization of data, and has noted that the current lack of interoperability is a contributing factor to the lack of adoption of available infrastructures. To address the problems of interoperability and reproducing previous results, we present an infrastructure that supports interoperability among reverse engineering tools and applications. We present the design of our infrastructure, including the hierarchy of schemas that captures the interactions among graph structures. We also develop and utilize our implementation, which is designed using a GXL-based pipe-filter architecture, to perform a case study that demonstrates the feasibility of our infrastructure.

[57] Mark Hennessy and James F. Power. Ensuring behavioural equivalence in test-driven porting. In 16th Annual International Conference on Computer Science and Software Engineering: Dublin Symposium, Dublin, Ireland, October 17 2006. [ bib | http | .pdf ]
In this paper we present a test-driven approach to porting code from one object-oriented language to another. We derive an order for the porting of the code, along with a testing strategy to verify the behaviour of the ported system at intra and inter-class level. We utilise the recently defined methodology for porting C++ applications, eXtreme porting, as a framework for porting. This defines a systematic routine based upon porting and unit-testing classes in turn. We augment this approach by using Object Relation Diagrams to define an order for porting that minimises class stubbing. Since our strategy is class-oriented and test-driven, we can ensure the structural equivalence of the ported system, along with the limited behavioural equivalence of each class. In order to extend this to integration-level equivalence, we exploit aspect-oriented programming to generate UML sequence diagrams, and we present a technique to compare such automatically-generated diagrams for equivalence. We demonstrate and evaluate our approach using a case study that involves porting an application from C++ to Java.

[56] Jacqueline A. McQuillan and James F. Power. Some observations on the application of software metrics to UML models. In MoDELS/UML Workshop on Model Size Metrics, Genova, Italy, October 3 2006. [ bib | .pdf ]
In this position paper we discuss some of the existing work on applying metrics to UML models, present some of our own work in this area, and specify some topics for future research that we regard as important.

[55] Jacqueline A. McQuillan and James F. Power. Experiences of using the Dagstuhl Middle Metamodel for defining software metrics. In Principles and Practice of Programming in Java, pages 194--198, Mannheim, Germany, August 30 - September 1 2006. [ bib | DOI | .pdf ]
In this paper we report on our experiences of using the Dagstuhl Middle Metamodel as a basis for defining a set of software metrics. This approach involves expressing the metrics as Object Constraint Language queries over the metamodel. We provide details of a system for specifying Java-based software metrics through a tool that instantiates the metamodel from Java class files and a tool that automatically generates a program to calculate the expressed metrics. We present details of an exploratory data analysis of some cohesion metrics to illustrate the use of our approach.

[54] Jacqueline A. McQuillan and James F. Power. Towards re-usable metric definitions at the meta-level. In PhD Workshop of the 20th European Conference on Object-Oriented Programming, Nantes, France, July 3-7 2006. [ bib | .pdf ]
A large number of metrics for evaluating the quality of software have been proposed in the literature. However, there is no standard terminology or formalism for dening metrics and consequently many of the metrics proposed have some ambiguity in their denitions. This hampers the empirical validation of these metrics. To address this problem, we generalise an existing approach to dening metrics that is based on the Object Constraint Language and the Unied Modelling Language metamodel. We have developed a prototype tool called DMML (Dening Metrics at the Meta Level) that supports this approach and we present details of this tool. To illustrate the approach, we present formal denitions for the Chidamber and Kemerer metrics suite.

[53] Brian A. Malloy and James F. Power. Exploiting design patterns to automate validation of class invariants. Software Testing, Verification and Reliability, 16(2):71--95, June 2006. [ bib | DOI | .pdf ]
In this paper, techniques are presented that exploit two design patterns, the Visitor pattern and the Decorator pattern, to automatically validate invariants about the data attributes in a C++ class. To investigate the pragmatics involved in using the two patterns, a study of an existing, well-tested application, keystone, a parser and front-end for the C++ language, is presented. Results from the study indicate that these two patterns provide flexibility in terms of the frequency and level of granularity of validation of the class invariants, which are expressed in the Object Constraint Language, OCL. The quantitative results measure the impact of these approaches and the additional faults uncovered through validation of the case study.

[52] Áine Mitchell and James F. Power. A study of the influence of coverage on the relationship between static and dynamic coupling metrics. Science of Computer Programming, 59(1-2):4--25, January 2006. [ bib | DOI | .pdf ]
This paper examines the relationship between the static coupling between objects (CBO) metric and some of its dynamic counterparts. The dimensions of the relationship for Java programs are investigated, and the influence of instruction coverage on this relationship is measured. An empirical evaluation of 14 Java programs taken from the SPEC JVM98 and the JOlden benchmark suites is conducted using the static CBO metric, six dynamic metrics and instruction coverage data. The results presented here confirm preliminary studies indicating the independence of static and dynamic coupling metrics, but point to a strong influence of coverage on the relationship. Based on this, this paper suggests that dynamic coupling metrics might be better interpreted in the context of coverage measures, rather than as stand-alone software metrics.

[51] Nicholas A. Kraft, Brian A. Malloy, and James F. Power. Toward an Infrastructure to Support Interoperability in Reverse Engineering. In 12th Working Conference on Reverse Engineering, pages 196--205, Pittsburgh, Pennsylvania, USA, November 8-11 2005. [ bib | DOI | .pdf ]
In this paper we present an infrastructure that supports interoperability among various reverse engineering tools and applications. We include an Application Programmer's Interface that permits extraction of information about declarations, including classes, functions and variables, as well as information about scopes, types and control statements in C++ applications. We also present a hierarchy of canonical schemas that capture minimal functionality for middle-level graph structures. This hierarchy facilitates an unbiased comparison of results for different tools that implement the same or a similar schema. We have a repository, hosted by SourceForge.net, where we have placed the artifacts of our infrastructure.

[50] Mark Hennessy and James F. Power. An Analysis of Rule Coverage as a Criterion in Generating Minimal Test Suites for Grammar-Based Software. In 20th IEEE/ACM International Conference on Automated Software Engineering, pages 104--113, Long Beach, California, USA, November 7-11 2005. [ bib | DOI | .pdf ]
The term grammar-based software describes software whose input can be specified by a context-free grammar. This grammar may occur explicitly in the software, in the form of an input specification to a parser generator, or implicitly, in the form of a hand-written parser, or other input-verification routines. Grammar-based software includes not only programming language compilers, but also tools for program analysis, reverse engineering, software metrics and documentation generation. Such tools often play a crucial role in automated software development, and ensuring their completeness and correctness is a vital prerequisite for their use. In this paper we propose a strategy for the construction of test suites for grammar based software, and illustrate this strategy using the ISO C++ grammar. We use the concept of rule coverage as a pivot for the reduction of implementation-based and specification-based test suites, and demonstrate a significant decrease in the size of these suites. To demonstrate the validity of the approach, we use the reduced test suite to analyze three grammar-based tools for C++. We compare the effectiveness of the reduced test suite with the original suite in terms of code coverage and fault detection.

[49] Nicholas A. Kraft, Brian A. Malloy, and James F. Power. g4re: Harnessing GCC to Reverse Engineer C++ Applications. In Transformation Techniques in Software Engineering: Dagstuhl Seminar Proceedings No. 05161, IBFI, Schloss Dagstuhl, Germany, April 17-22 2005. [ bib | http | .pdf ]
In this paper, we describe g4re, our tool chain that exploits GENERIC, an intermediate format incorporated into the gcc C++ compiler, to facilitate analysis of real C++ applications. The gcc GENERIC representation is available through a file generated for each translation unit (tu), and g4re reads each tu file and constructs a corresponding Abstract Semantic Graph (ASG). Since tu files can be prohibitively large, ranging from 10 megabytes for a "hello world" program, to 18 gigabytes for a version of Mozilla Thunderbird, we describe our approach for reducing the size of the generated ASG.

[48] Brian A. Malloy and James F. Power. Using a Molecular Metaphor to Facilitate Comprehension of 3D Object Diagrams. In IEEE Symposium on Visual Languages and Human-Centric Computing, pages 233--240, Dallas, Texas, USA, September 20-24 2005. [ bib | DOI | .pdf ]
This paper presents a strategy for the visualization of dynamic object relationships in Java programs. The metaphor of a chemical molecule is used to aid comprehension, and to help in reducing the size of the object graph. Our strategy has been implemented by dynamically instrumenting Java bytecode to collect trace data, which is then analyzed and visualized in 3D using VRML. Quantitative and graphical results are presented, based on an analysis of programs in the SPEC JVM98 and JOlden benchmark suites.

[47] David Sinclair and James F. Power. Specifying and Verifying Communications Protocols using Mixed Intuitionistic Linear Logic. Electronic Notes in Theoretical Computer Science, 133:255--273, 31 May 2005. [ bib | DOI | .pdf ]
This paper presents an outline specification of the IP and TCP communication protocols in mixed intuitionistic linear logic and describes how this logic can be used to prove some properties of both protocols. We have previously presented a specification of IP in using commutative linear logic; in this paper we extend this specification considerably to include TCP, which, in turn, necessitates the use of non-commutative operators.

[46] Brian A. Malloy and James F. Power. Exploiting UML dynamic object modeling for the visualization of C++ programs. In ACM Symposium on Software Visualization, pages 105--114, St. Louis, Missouri, USA, May 15-16 2005. [ bib | DOI | .pdf ]
In this paper we present an approach to modeling and visualizing the dynamic interactions among objects in a C++ application. We exploit UML diagrams to expressively visualize both the static and dynamic properties of the application. We make use of a class diagram and call graph of the application to select the parts of the application to be modeled, thereby reducing the number of objects and methods under consideration with a concomitant reduction in the cognitive burden on the user of our system. We use aspects to insert probes into the application to enable profiling of the interactions of objects and methods and we visualize these interactions by providing sequence and communication diagrams for the parts of the program under consideration. We complement our static selectors with dynamic selectors that enable the user to further filter objects and methods from the sequence and communication diagrams, further enhancing the cognitive economy of our system. A key feature of our approach is the provision for dynamic interaction with both the profiler and the application. Interaction with the profiler enables filtering of methods and objects. Interaction with the application enables the user to supply input to the application to provide direction and enhance comprehension or debugging.

[45] James F. Power and John T. Waldron. Editorial: Special Issue on the Principles and Practice of Programming in Java. Science of Computer Programming, 54(1):1--2, January 2005. [ bib | DOI | .pdf ]
It gives us great pleasure to present this special issue, containing papers from the conference on the Principles and Practice of Programming in Java held in Kilkenny City, Ireland, in June 2003. All authors of full papers presented at PPPJ 2003 were invited to submit revised and extended version of their papers for this special issue. These papers were rigorously reviewed, resulting in the six papers presented here.

[44] Stephen Brown, Áine Mitchell, and James F. Power. A Coverage Analysis of Java Benchmark Suites. In The IASTED International Conference on Software Engineering, pages 144--150, Innsbruck, Austria, February 15-17 2005. [ bib | .pdf ]
The Java programming language provides an almost ideal environment for both static and dynamic analysis, being easy to parse, and supporting a standardised, easily-profiled virtual environment. In this paper we study the relationship between results obtainable from static and dynamic analysis of Java programs, and in particular the difficulties of correlating static and dynamic results. As a foundation for this study, we focus on various criteria related to run-time code coverage, as commonly used in test suite analysis. We have implemented a dynamic coverage analysis tool for Java programs, and we use it to evaluate several standard Java benchmark suites using line, instruction and branch coverage criteria. We present data indicating a considerable variance in static and dynamic analysis results between these suites, and even between programs in these suites.

[43] Áine Mitchell and James F. Power. Using Object-Level Run-Time Metrics to Study Coupling Between Objects. In 20th Annual ACM Symposium on Applied Computing, pages 1456 -- 1462, Santa Fe, New Mexico, March 13 -17 2005. [ bib | DOI | .pdf ]
In this paper we present an investigation into the run-time behaviour of objects in Java programs, using specially adapted coupling metrics. We identify objects from the same class that exhibit non-uniform coupling behaviour when measured dynamically. We define a number of object level run-time metrics, based on the static Chidamber and Kemerer coupling between objects (CBO) measure. These new metrics seek to quantify coupling at different layers of granularity, that is at class-class and object-class level. We outline our method of collecting such metrics and present a study of the programs from the JOlden benchmark suite as an example of their use. A number of statistical techniques, principally agglomerative hierarchical clustering analysis, are used to facilitate the identification of such objects.

[42] David Gregg, James F. Power, and John Waldron. A method-level comparison of the Java Grande and SPEC JVM98 benchmark suites. Concurrency and Computation: Practice and Experience, 17(7-8):757--773, June-July 2005. [ bib | DOI | .pdf ]
In this paper we seek to provide a foundation for the study of the level of use of object-oriented techniques in Java programs in general, and scientific applications in particular. In particular we investigate the profiles of Java programs from a number of perspectives, including the use of class library methods, the size of methods called, the mode of invoke instruction used and the polymorphicity of call sites. We also present a categorisation of the nature of small-sized methods used in Java programs. We compare the Java Grande and SPEC JVM98 benchmark suites, and note a significant difference in the nature and composition of these suites, with the programs from the Java Grande suite demonstrating a less object-oriented approach.

[41] James F. Power and Brian A. Malloy. A metrics suite for grammar-based software. Software Maintenance and Evolution: Research and Practice, 16(6):405--426, November/December 2004. [ bib | DOI | http | .pdf ]
One approach to measuring and managing the complexity of software, as it evolves over time, is to exploit software metrics. Metrics have been used to estimate the complexity of the maintenance effort, to facilitate change impact analysis, and as an indicator for automatic detection of a transformation that can improve the quality of a system. However, there has been little effort directed at applying software metrics to the maintenance of grammar-based software applications, such as compilers, editors, program comprehension tools and embedded systems. In this paper, we adapt the software metrics that are commonly used to measure program complexity and apply them to the measurement of the complexity of grammar-based software applications. Since the behaviour of a grammar-based application is typically choreographed by the grammar rules, the measure of complexity that our metrics provide can guide maintainers in locating problematic areas in grammar-based applications.

[40] James F. Power and David Sinclair. A Formal Model of Forth Control Words in the Pi-Calculus. Journal of Universal Computer Science, 10(9):1272--1293, September 2004. [ bib | DOI | http | .pdf ]
In this paper we develop a formal specification of aspects of the Forth programming language. We describe the operation of the Forth compiler as it translates Forth control words, dealing in particular with the interpretation of immediate words during compilation. Our goal here is to provide a basis for the study of safety properties of embedded systems, many of which are constructed using Forth or Forth-like languages. To this end we construct a model of the Forth compiler in the pi-calculus, and have simulated its execution by animating this model using the Pict programming language.

[39] Diarmuid O'Donoghue and James F. Power. Identifying and evaluating a generic set of superinstructions for embedded Java programs. In International Conference on Embedded Systems and Applications, pages 192--198, Las Vegas, Nevada, USA, June 21-24 2004. [ bib | .pdf ]
In this paper we present an approach to the optimisation of interpreted Java programs using superinstructions. Unlike existing techniques, we examine the feasibility of identifying a generic set of superinstructions across a suite of programs, and implementing them statically on a JVM. We formally present the sequence analysis algorithm and we describe the resulting sets of superinstructions for programs from the embedded CaffeineMark benchmark suite. We have implemented the approach on the Jam VM, a lightweight JVM, and we present results showing the level of speedup possible from this

[38] Áine Mitchell and James F. Power. Run-Time Cohesion Metrics: An Empirical Investigation. In International Conference on Software Engineering Research and Practice, pages 532--537, Las Vegas, Nevada, USA, June 21-24 2004. [ bib | .pdf ]
Cohesion is one of the fundamental measures of the 'goodness' of a software design. The most accepted and widely studied object-oriented cohesion metric is Chidamber and Kemerer's Lack of Cohesion in Methods measure. However due to the nature of object-oriented programs, static design metrics fail to quantify all the underlying dimensions of cohesion, as program behaviour is a function of it operational environment as well as the complexity of the source code. For these reasons two run-time object-oriented cohesion metrics are described in this paper, and applied to Java programs from the SPECjvm98 benchmark suite. A statistical analysis is conducted to assess the fundamental properties of the measures and investigate whether they are redundant with respect to the static cohesion metric. Results to date indicate that run-time cohesion metrics can provide an interesting and informative qualitative analysis of a program and complement existing static cohesion metrics.

[37] Áine Mitchell and James F. Power. An Empirical Investigation into the Dimensions of Run-Time Coupling Metrics in Java programs. In The Third International Conference on the Principles and Practice of Programming in Java, pages 9--14, Las Vegas, Nevada, USA, June 16-18 2004. [ bib | http | .pdf ]
Software quality is an important external software attribute that is difficult to measure objectively. Several studies have identified a clear empirical relationship between static coupling metrics and software quality. However due to the nature of object-oriented program static metrics fail to quantify all the underlying dimensions of coupling, as program behaviour is a function of it operational environment as well as the complexity of the source code. In this paper a set of run-time object-oriented coupling metrics are described and empirically validated in terms of their usefulness in predicting software quality. Preliminary results indicate that run-time coupling metrics can provide an interesting and informative qualitative analysis of a program and complement existing static coupling metrics.

[36] Áine Mitchell and James F. Power. An approach to quantifying the run-time behaviour of Java GUI applications. In Winter International Symposium on Information and Communication Technologies, Cancun, Mexico, January 5-8 2004. [ bib | http | .pdf ]
This paper outlines a new technique for collecting dynamic trace information from Java GUI programs. The problems of collecting run-time information from such interactive applications in comparison with traditional batch style execution benchmark programs is outlined. The possible utility of such run-time information is discussed and from this a number of simple run-time metrics are suggested. The metrics results for a small CelsiusConverter Java GUI program are illustrated to demonstrate the viability of such an analysis.

[35] Brian A. Malloy, James. F. Power, and Tanton H. Gibbs. C++ Compilers and ISO Conformance. Dr. Dobb's Journal, 28(11):54--60, November 2003. [ bib | http ]
In this article we revisit the C++ conformance study we presented in "Testing C++ Compilers for ISO Language Conformance" (DDJ, June 2002). In doing so, we provide some measure of conformance to the ISO Standard for eight C++ compilers: Borland 6.0, Comeau 4.3.2, EDG 3.2, gcc 3.3, Intel 7.1, PGCC 4.1-2, Visual C++ 7.1 and Watcom 1.0.

[34] Áine Mitchell and James F. Power. Toward a definition of run-time object-oriented metrics. In 7th ECOOP Workshop on Quantitative Approaches in Object-Oriented Software Engineering, Darmstadt, Germany, July 21-25 2003. [ bib | .pdf ]
This position paper outlines a programme of research based on the quantification of run-time elements of Java programs. In particular, we adapt two common objectoriented metrics, coupling and cohesion, so that they can be applied at run-time. We demonstrate some preliminary results of our analysis on programs from the SPEC JVM98 benchmark suite.

[33] Mark Hennessy, Brian Malloy, and James Power. gccXfront: Exploiting gcc as a Front End for Program Comprehension Tools via XML/XSLT. In 11th IEEE International Workshop on Program Comprehension, (Tool Demo), pages 298--299, Portland, Oregon, USA, May 9-11 2003. [ bib | http | .pdf ]
Parsing programming languages is an essential component of the front end of most program comprehension tools. Languages such as C++ can be difficult to parse and so it can prove useful to re-use existing front ends such as those from the GNU compiler collection, gcc. We have modified gcc to provide syntactic tags in XML format around the source code which can greatly enhance our comprehension of the program structure. Further, by using XML transformation stylesheets, the XML outputted by our modified gcc can be translated into a more readable format. Our tool, gccXfront leverages the power and portability of the gcc suite, since any C, C++, Objective C or Java program can be processed using gcc. Our tool can thus act as a bridge between gcc and other program comprehension tools that accept XML formatted input.

[32] David Gregg, James Power, and John Waldron. Platform independent dynamic Java virtual machine analysis: the Java Grande Forum benchmark suite. Concurrency and Computation: Practice and Experience, 15(3-5):459--484, March 2003. [ bib | DOI | http ]
In this paper we present a platform independent analysis of the dynamic profiles of Java programs when executing on the Java Virtual Machine. The Java programs selected are taken from the Java Grande Forum benchmark suite and five different Java-to-bytecode compilers are analysed. The results presented describe the dynamic instruction usage frequencies, as well as the sizes of the local variable, parameter and operand stacks during execution on the JVM.These results, presenting a picture of the actual (rather than presumed) behaviour of the JVM, have implications both for the coverage aspects of the Java Grande benchmark suites, for the performance of the Java-to-bytecode compilers and for the design of the JVM.

[31] Brian A. Malloy, Tanton H. Gibbs, and James F. Power. Decorating tokens to facilitate recognition of ambiguous language constructs. Software: Practice and Experience, 33(1):19--39, January 2003. [ bib | DOI | http ]
Software tools are fundamental to the comprehension, analysis, testing and debugging of application systems. A necessary first step in the development of many tools is the construction of a parser front-end that can recognize the implementation language of the system under development. In this paper, we describe our use of token decoration to facilitate recognition of ambiguous language constructs. We apply our approach to the C++ language since its grammar is replete with ambiguous derivations such as the declaration/expression and template-declaration/expression ambiguity. We describe our implementation of a parser front-end for C++, keystone, and we describe our results in decorating tokens for our test suite including the examples from Clause Three of the C++ standard. We are currently exploiting the keystone front-end to develop a taxonomy for implementation-based class testing and to reverse-engineer Unified Modeling Language (UML) class diagrams.

[30] James F. Power and John T. Waldron (Eds.). Recent Advances in Java Technology: Theory, Application, Implementation. Computer Science Press, Trinity College Dublin, November 2002. [ bib | .pdf ]
Since its launch, the Java programming language has quickly established itself as a backbone technology in many areas of computer science and information systems. By leveraging the power, reliability and portability of the Java framework, applications developers have harnessed a means of creating robust and mobile applications. In RECENT ADVANCES IN JAVA TECHNOLOGY we investigate the present day widespread use of Java and Java related technologies to provide a platform for cutting-edge developments in software.

[29] D. Gregg, J.F. Power, and J.T. Waldron. Measuring the impact of object-oriented techniques in Grande applications: a method-level analysis. In Joint ACM-ISCOPE Conference on Java Grande (Poster Session), pages 229--229, Seattle, Washington, USA, November 3-5 2002. [ bib | http | .pdf ]
In this work we seek to provide a foundation for the study of the level of use of object-oriented techniques in Java programs in general, and scientific applications in particular. Specifically, we focus on the use of small methods, and the frequency with which they are called, since this forms the basis for the study of method inlining, an important optimisation technique. We compare the Grande and SPEC benchmark suites, and note a significant difference in the nature and composition of these suites.

[28] J.F. Power and B.A. Malloy. Program annotation in XML: a parser-based approach. In 9th IEEE Working Conference on Reverse Engineering, pages 190--198, Richmond, Virginia, USA, October 28 - November 1 2002. [ bib | http | .pdf ]
In this paper we describe a technique that can be used to annotate source code with syntactic tags in XML format. This is achieved by modifying the parser generator bison to emit these tags for an arbitrary grammar. We also discuss an immediate application of this technique, a portable modification of the gcc compiler, that allows for XML output for C, Objective C, C++ and Java programs. While our approach does not have the same semantic richness as other approaches, it does have the advantage of being language independent, and thus re-usable in a number of different domains.

[27] T.H. Gibbs, B.A. Malloy, and J.F. Power. Automated Validation of Class Invariants in C++ Applications. In 17th IEEE International Conference on Automated Software Engineering, pages 205--214, Edinburgh, UK, September 23-27 2002. [ bib | http | .pdf ]
In this paper, we describe a non-invasive approach for validation of class invariants in C++ applications. Our approach is fully automated so that the user need only supply the class invariants for each class hierarchy to be checked and our validator constructs an InvariantVisitor, a variation of the Visitor Pattern, and an InvariantFacilitator. Instantiations of the InvariantVisitor and InvariantFacilitator classes encapsulate the invariants in C++ statements and facilitate the validation of the invariants. We describe both our approach and our results of validating invariants in keystone, a well tested parser front-end for C++.

[26] B. A. Malloy, J. F. Power, and J. T. Waldron. Applying Software Engineering Techniques to Parser Design. In Conference of the South African Institute of Computer Scientists and Information Technologists, pages 75--82, Port Elizabeth, South Africa, September 16-18 2002. [ bib | http | .pdf ]
In this paper we describe the development of a parser for the C# programming language. We outline the development process used, detail its application to the development of a C# parser and present a number of metrics that describe the parser's evolution. This paper presents and reinforces an argument for the application of software engineering techniques in the area of parser design. The development of a parser for the C# programming language is in itself important to software engineering, since parsers form the basis for tools such as metrics generators, refactoring tools, pretty-printers and reverse engineering tools.

[25] D. O'Donoghue, A. Leddy, J.F. Power, and J.T. Waldron. Bi-gram Analysis of Java Bytecode Sequences. In Proceedings of the Second Workshop on Intermediate Representation Engineering for the Java Virtual Machine, pages 187--192, Trinity College, Dublin, Ireland, June 13-14 2002. [ bib | http | .pdf ]
We report on a project that performed a bigram analysis of dynamic bytecode sequences. The objective was to identify the most commonly used bytecode pairs, and to examine the relative frequency of occurrence of these bytecodes. In all, 12 large Java programs were analysed, taken from the Java Grande and SPEC benchmark suites. Our findings are of relevance to research into instruction set design and implementation, as well as JVM optimisation.

[24] Brian A. Malloy, Scott A. Linde, Edward B. Duffy, and James F. Power. Testing C++ Compilers for ISO Language Conformance. Dr. Dobb's Journal, (337):71--78, June 2002. [ bib | http | .pdf ]
In this paper, we describe our construction of a test harness to measure conformance of some popular C++ compilers and to measure the progress of the gcc C++ compiler as it moves toward ISO conformance. In an attempt to apply the same standard to all of the vendors, we use the same test cases and the same testing framework for all executions, even though some of the compilers are platform dependent and there is no common platform for all compilers. We found that the Python language provided the functionality that we needed with its scripting facility, its platform independence and its object orientation to facilitate code reuse. Python includes a testing framework as a module of the language and we have extended the framework to measure C++ ISO conformance.

[23] T. Dowling, J. Power, and J. Waldron. Relating Static and Dynamic Measurements for the Java Virtual Machine Instruction Set, pages 106--111. WSEAS Press, 2002. [ bib ]
This is a book-length version of our MMACTEE '01 paper.

[22] D. Gregg, J. Power, and J. Waldron. Benchmarking the Java Virtual Architecture - The SPEC JVM98 Benchmark Suite, chapter 1, pages 1--18. Kluwer Academic, 2002. [ bib | DOI | .pdf ]
In this chapter we present a study of the SPEC JVM98 benchmark suite at a dynamic platform-independent level. The results presented describe the influence of class library code, the relative importance of various methods in the suite, as well as the sizes of the local variable, parameter and operand stacks. We also examine the dynamic bytecode instruction usage frequencies, and discuss their relevance. The influence of the choice of Java source to bytecode compiler is shown to be relatively insignificant at present.

[21] Sarah Matzko, Peter J. Clarke, Tanton H. Gibbs, Brian A. Malloy, James F. Power, and Rosemary Monahan. Reveal: A Tool to Reverse Engineer Class Diagrams. In Fortieth International Conference on Technology of Object-Oriented Languages and Systems, pages 13--21, Sydney, Australia, February 18-21 2002. [ bib | http | .pdf ]
Many systems are constructed without the use of modeling and visualization artifacts, due to constraints imposed by deadlines or a shortage of manpower. Nevertheless, such systems might profit from the visualization provided by diagrams to facilitate maintenance of the constructed system. In this paper, we present a tool, Reveal, to reverse engineer a class diagram from the C++ source code representation of the software. In Reveal, we remain faithful to the UML standard definition of a class diagram wherever possible. However, to accommodate the vagaries of the C++ language, we offer some extensions to the standard notation to include representations for namespaces, stand-alone functions and friend functions. We compare our representation to three other tools that reverse-engineer class diagrams, for both compliance to the UML standard and for their ability to faithfully represent the software system under study.

[20] T. Dowling, J. Power, and J. Waldron. Relating Static and Dynamic Measurements for the Java Virtual Machine Instruction Set. In Symposium on Mathematical Methods and Computational Techniques in Electronic Engineering, Athens, Greece, December 29-31 2001. [ bib | .pdf ]
It has previously been noted that, for conventional machine code, there is a strong relationship between static and dynamic code measurements. One of the goals of this paper is to examine whether this same relationship is true of Java programs at the bytecode level. To this end, the hypothesis of a linear correlation between static and dynamic frequencies was investigated using Pearson's correlation coefficient. Programs from the Java Grande and SPEC benchmarks suites were used in the analysis.

[19] Jane Horgan, James Power, and John Waldron. Measurement and Analysis of Runtime Profiling Data for Java Programs. In IEEE International Workshop on Source Code Analysis and Manipulation, Florence, Italy, November 10 2001. [ bib | http | .pdf ]
In this paper we examine a procedure for the analysis of data produced by the dynamic profiling of Java programs. In particular, we describe the issues involved in dynamic analysis, propose a metric for discrimination between the resulting data sets, and examine its application over different test suites and compilers.

[18] Charles Daly, Jane Horgan, James Power, and John Waldron. Gender and Learning Systems. In Third International Conference on Women in Africa and the African Diaspora, Antananarivo/Tamatave, Madagascar, October 8-17 2001. [ bib ]
A great deal of research has been done on gender issues in computer science education but very little on the relationship between automated learning systems and gender. The benefits of such systems have not been exploited to their full extent in developing countries where educational resources and qualified instructors are at a premium. The system which we present here, MIPSMARK, can be used for learning and assessment with minimum intervention of the lecturer, and is freely available on the web.

[17] Brian A. Malloy and James F. Power. An Interpretation of Purdom's Algorithm for Automatic Generation of Test Cases. In 1st Annual International Conference on Computer and Information Science, Orlando, Florida, USA, October 3-5 2001. [ bib | .pdf ]
We present a structured reformulation of the seminal algorithm for automatic generation of test cases for a context-free grammar. Our reformulation simplifies the algorithm in several ways. First, we provide a structured reformulation so that it is obvious where to proceed at each step. Second, we partition the intricate third phase into five functions, so that the discussion and comprehension of this phase can be modularized. Our implementation of the algorithm provides information about the grammatic, syntactic and semantic correctness of the generated test cases for two important languages in use today: C and C++. The results of our study of C and C++ highlight a lacuna latent in the research to date. In particular, if one or more of the automatically generated test cases is syntactically or semantically incorrect, then the confidence of structural “coverage” may be compromised for the particular grammar-based tool under test. Our ongoing work focuses on a solution to this problem.

[16] B. Aziz, D. Gray, G. Hamilton, F. Oehl, J. Power, and D. Sinclair. Implementing Protocol Verification for E-Commerce. In International Conference on Advances in Infrastructure for Electronic Business, Science, and Education on the Internet, L'Aquila, Italy, Aug 6-12 2001. [ bib | .pdf ]
This paper presents a survey of the practical application of protocol verification techniques to applications in e­commerce. We concentrate in particular on logic­based approaches, and review the current state of the art as well as the prospects for realistic deployment of protocol verification techniques in the near future.

[15] S. Byrne, J. Power, and J. Waldron. A Dynamic Comparison of the SPEC98 and Java Grande Benchmark Suites. In Workshop on Intermediate Representation Engineering for the Java Virtual Machine, pages 95--98, Orlando, Florida, USA, July 22-25 2001. [ bib | .pdf ]
Two of the most commonly used benchmark suites for Java Programs are the SPEC98 and Grande Forum benchmark suites. This research uses a Platform Independent Dynamic Analysis Technique to study these suites and quantify the significant similarities and differences in behaviour between the suites. Dynamic frequencies adduced include method execution divided into program, API and native cat- egories. The most informative basis for measurement is shown to be percentages of executed bytecodes charged to each method, and results are reported for the API packages.

[14] James Power and David Sinclair. A Formal Model of Forth Control Words in the Pi-Calculus. In 6th International Workshop on Formal Methods for Industrial Critical Systems, Paris, France, July 16-17 2001. [ bib | .pdf ]
In this paper we develop a formal specification of aspects of the Forth programming language. We describe the operation of the Forth compiler as it translates Forth control words, dealing in particular with the interpretation of immediate words during compilation. Our goal here is to provide a basis for the study of safety properties of embedded systems, many of which are constructed using Forth or Forth-like languages. To this end we construct a model of the Forth compiler in the pi-calculus, and have simulated its execution by animating this model using the pict programming language.

[13] Karsten Fritsche, James Power, and John Waldron. A Java Distributed Computation Library. In Second International Conference on Parallel and Distributed Computing, Applications and Technologies, Taipei, Taiwan, July 9-11 2001. [ bib | .pdf ]
This paper describes the design and development of a Java Distributed Computation Library, which provides a simple development platform for developers who wish to quickly implement a distributed computation in the context of an SPMD architecture (Single Program, Multiple Data). The need for this research arose out of the realisation that the currently available distributed computation libraries and systems do not adequately meet certain criteria, such as ease of development, dynamic changes to system behaviour, and easy deployment of distributed software. The proposed solution to this problem was to produce a Java-based distributed computation library which enables developers to use the Java language to quickly and easily implement a distributed computation. The results of experiments conducted using DCL are also presented, as a means of showing that DCL met its design goals.

[12] Charles Daly, Jane Horgan, James Power, and John Waldron. Platform Independent Dynamic Java Virtual Machine Analysis: the Java Grande Forum Benchmark Suite. In Joint ACM Java Grande - ISCOPE 2001 Conference, Stanford University, USA, June 2-4 2001. [ bib | http | .pdf ]
In this paper we present a platform independent analysis of the dynamic profiles of Java programs when executing on the Java Virtual Machine. The Java programs selected are taken from the Java Grande Forum benchmark suite, and five different Java-to-bytecode compilers are analysed. The results presented describe the dynamic instruction usage frequencies, as well as the sizes of the local variable, parameter and operand stacks during execution on the JVM. These results, presenting a picture of the actual (rather than presumed) behaviour of the JVM, have implications both for the coverage aspects of the Java Grande benchmark suites, for the performance of the Java-to-bytecode compilers, and for the design of the JVM.

[11] David Gray, Geoff Hamilton, James Power, and David Sinclair. A Specification of TCP/IP using Mixed Intuitionistic Linear Logic (Extended Abstract) . In 2nd Joint Workshop on Formal Specification of Computer-Based Systems, Washington DC, USA, 20 April 2001. [ bib | .pdf ]
This paper presents an outline specification of the IP and TCP communication protocols in mixed intuitionistic linear logic and describes how this logic can be used to prove some properties of both protocols. We have previously presented a specification of IP using commutative linear logic; in this paper we extend this specification considerably to include TCP, which, in turn, necessitates the use of non-commutative operators.

[10] Charles Daly, Jane Horgan, James Power, and John Waldron. Some measurements of Java-to-byecode compiler performance in the Java Virtual Machine. In Workshop on Java Optimization Strategies for Embedded Systems, University of Genova, Italy, April 1 2001. [ bib | .pdf ]
In this paper we present a platform independent analysis of the dynamic profiles of Java programs when executing on the Java Virtual Machine. The Java programs selected are taken from the Java Grande Forum benchmark suite, and five different Java-to-bytecode compilers are analysed. The results presented describe the dynamic instruction usage frequencies.

[9] James Power and Brian Malloy. Exploiting Metrics to Facilitate Grammar Transformation into LALR Format. In 16th ACM Symposium on Applied Computing, Las Vegas, USA, March 11-14 2001. [ bib | http | .pdf ]
The recently-standardized ISO C++ programming language has a large and complex grammar and, due to the nature of the language, any C++ parser must exhibit tight coupling with subsequent phases of program processing. The preparation of input suitable for yacc in this case involves taking the original ISO C++ grammar, designed for readability, and refining it towards a version acceptable to yacc's parsing algorithm. Since the structure of the whole ISO C++ standard closely follows the ISO C++ grammar, and since this grammar is a widely-accepted standard, it is desirable that the yacc source for the parser resemble it as closely as possible. The design process of the parser, then, involves a continuous trade-off between preserving the grammar's structure, and rearranging it to ease implementation. We exploit software metrics, as an aid towards estimating the com- plexity of this task, and providing a means of assessing the relative merits of these trade-offs. We see this work as part of a larger process of designing well-engineered, re-usable and reliable program processors, which themselves will play an important role in the future design of code-based software-engineering tools.

[8] James F. Power and Brian A. Malloy. Symbol Table Construction and Name Lookup in ISO C++. In 37th International Conference on Technology of Object-Oriented Languages and Systems, Sydney, Australia, November 20-23 2000. [ bib | .pdf ]
In this paper, we present an object-oriented model of symbol table construction and name lookup for ISO C++ using the Unified Modeling Language (UML). Our use of UML class, activity and sequence diagrams serves to explicate our model and our use of patterns such as decorator and facade increase the understandability of the model. Clause three of the ISO C++ standard describes the procedures and rules for performing name lookup; our activity and sequence diagrams serve to simulate these procedures in graphical fashion. An advantage of our approach is that our model can increase C++ understandability for those practitioners with a working UML knowledge.

[7] Lisa Cosgrave, James Power, and John Waldron. An Object Oriented Approach to Parser Generation in C++. In Conference of the South African Institute of Computer Scientists and Information Technologists, Cape Town, South Africa, November 1-3 2000. [ bib | .pdf ]
In this paper we describe the design and implementation of a system for representing context-free grammars in C++. The system allows for grammar representation at the object level, providing enhanced modularity and flexibility when compared to traditional generator-based approaches. We also describe the transformation of grammar flow analysis problems into an object-oriented framework using the Visitor pattern, as well as the implementation of a top-down LL(1) parser. As such, this work represents the synthesis of three presently disparate fields in parser design and implementation: combinator parsing, fixpoint-based grammar flow analysis, and object-oriented design.

[6] John Waldron and James Power. Comparison of Bytecode and Stack Frame Usage by Eiffel and Java Programs in the Java Virtual Machine. In 2nd International Workshop on Computer Science and Information Technologies, Ufa, Russia, September 18-23 2000. [ bib | .pdf ]
Dynamic quantatative measurements Bytecode and Stack Frame Usage by Eiffel and Java Programs in the Java Virtual Machine are made. Two Eiffel programs are dynamically analysed while executing on the JVM, and the results compared with those from the Java Programs. The aim is to examine whether properties like instruction usage and stack frame size are properties of the Java programming language itself or are exhibited by Eiffel programs as well. Remarkably local_load, push_const and local_store always account for very close to 40% of instructions executed, a property of the Java Virtual Machine irrespective of the programming language compiler or compiler optimizations used.

[5] James Power and Brian Malloy. Metric-Based Analysis of Context-Free Grammars. In 8th IEEE International Workshop on Program Comprehension, Limerick, Ireland, 10-11 June 2000. [ bib | .pdf ]
Recent advances in software engineering have produced a variety of well established approaches, formalisms and techniques to facilitate the construction of large-scale applications. Developers interested in the construction of robust, extensible software that is easy to maintain should expect to deploy a range of these techniques, as appropriate to the task. In this paper, we provide a foundation for the application of established software metrics to the measurement of context-free grammars. The usual application of software metrics is to program code; we provide a mapping that allows these metrics to be applied to grammars. This allows us to interpret six software engineering metrics in a grammatical context, including McCabe's complexity metric and Fenton's impurity metric. We have designed and implemented a tool to automatically compute the six metrics; as a case study, we use these six metrics to measure some of the properties of grammars for the Oberon, ISO C, ISO C++ and Java programming languages. We believe that the techniques that we have developed can be applied to estimating the difficulty of designing, implementing, testing and maintaining parsers for large grammars.

[4] David Sinclair, James Power, Paul Gibson, David Gray, , and Geoff Hamilton. Specifying and Verifying IP with Linear Logic. In International Workshop on Distributed Systems Validation and Verification, Taipei, Taiwan, ROC, April 10 2000. [ bib | .pdf ]
This paper presents a specification of the IP layer in linear logic and shows how linear logic can be used to prove some properties of this layer. Both the specification and the correctness proofs have been validated using the Coq proof assistant, via the authors' embedding of linear logic into this constructive framework.

[3] James F. Power and Brian A. Malloy. An Approach for Modeling the Name Lookup Problem in the C++ Programming Language. In 15th ACM Symposium on Applied Computing, Villa Olmo, Como, Italy, March 19-21 2000. [ bib | DOI | .pdf ]
Formal grammars are well established for specifying the syntax of programming languages. However, the formal specification of programming language semantics has proven more elusive. A recent standard, the Unified Modeling Language (UML), has quickly become established as a common framework for the specification of large scale software applications. In this paper, we describe an approach for using the UML to specify aspects of the static semantics of programming languages. In particular, we describe a technique for solving the name lookup problem for the recently standardized C++ programming language. We apply our approach to C++ because a solution to the name lookup problem is required for parser construction and our solution can be applied to Java and other programming languages.

[2] James Power and Caroline Webster. Working with Linear Logic in Coq. In 12th International Conference on Theorem Proving in Higher Order Logics (Work-in-progress paper), University of Nice, France, September 14-17 1999. [ bib | http | .pdf ]
In this paper we describe the encoding of linear logic in the Coq system, a proof assistant for higher-order logic. This process involved encoding a suitable consequence relation, the relevant operators, and some auxiliary theorems and tactics. The encoding allows us to state and prove theorems in linear logic, and we demonstrate its use through two examples: a simple blocks world scenario, and the Towers of Hanoi problem.

[1] David Gray, Geoff Hamilton, David Sinclair, Paul Gibson, and James Power. Four Logics and a Protocol. In 3rd. Irish Workshop in Formal Methods, National University of Ireland, Galway, Ireland, July 1-2 1999. [ bib | .pdf ]
The Internet Protocol (IP) is the protocol used to provide connectionless communication between hosts connected to the Internet. It provides a basic internetworking service to transport protocols such as Transmission Control Protocol (TCP) and User Datagram Protocol (UDP). These in turn provide both connection-oriented and connectionless services to applications such as file transfer (FTP) and WWW browsing. In this paper we present four separate specifications of the interface to the internetworking layer implemented by IP using four types of logic: classical, constructive, temporal and linear logic.


This file was generated by bibtex2html 1.98.

Before 1999: See previous work

James Power,
Dept. of Computer Science, Maynooth University
Last revised: Thursday September 14, 2017