through the design and implementation of a JVM that supports Pluggable Verification Modules (PVMs), the idea of an extensible protection mechanism is entertained. Link-time bytecode verification becomes a pluggable se...
详细信息
ISBN:
(纸本)1581138318
through the design and implementation of a JVM that supports Pluggable Verification Modules (PVMs), the idea of an extensible protection mechanism is entertained. Link-time bytecode verification becomes a pluggable service that can be readily replaced, reconfigured and augmented. Application-specific verification services can be safely introduced into the dynamic linking process of the JVM. this feature is enabled by the adoption of a previously proposed modular verification architecture, Proof Linking [23, 24], which decouples bytecode verification from the dynamic linking process, rendering the verifier a replaceable module. the PVM mechanism has been implemented in an open source JVM, the Aegis VM [21]. To evaluate the software engineering and security engineering benefits of this extensible protection mechanism, an augmented type system JAC (Java Access Control) [37] has been successfully implemented as a PVM.
Mock objects is an extension to Test-Driven Development that supports good object-oriented design by guiding the discovery of a coherent system of types within a code base. It turns out to be less interesting as a tec...
详细信息
ISBN:
(纸本)1581138334
Mock objects is an extension to Test-Driven Development that supports good object-oriented design by guiding the discovery of a coherent system of types within a code base. It turns out to be less interesting as a technique for isolating tests from third-party libraries than is widely thought. this paper describes the process of using Mock objects with an extended example and reports best and worst practices gained from experience of applying the process. It also introduces jMock, a Java framework that embodies our collective experience.
One of the most distinctive features of the Java (TM) programming language is the ability to specify class loading policies. Despite the popularity of class loaders, little has been done to reduce the cost associated ...
详细信息
ISBN:
(纸本)354027992X
One of the most distinctive features of the Java (TM) programming language is the ability to specify class loading policies. Despite the popularity of class loaders, little has been done to reduce the cost associated with defining the same class by multiple loaders. In particular, implementations of the Java virtual machine (JVM (TM)) create a complete runtime representation of each class regardless of how many class loaders already define the same class. this lack of sharing leads to poor memory utilization and to replicated run-time work. Recent efforts achieve some degree of sharing only when dynamic binding behaves predictably across loaders. this limits sharing to class loaders whose behavior is fully controlled by the JVM. As a result applications that implement their own class loading policies cannot enjoy the benefit of sharing. We present a novel technique for sharing the runtime representation of classes (including bytecodes and, under some conditions, compiled code) across arbitrary user-defined class loaders. We describe how our approach is applied to the multi-tasking virtual machine (MVM). the new multi-tasking virtual machine retains the fast start-up time of the original MVM while extending the scope of footprint savings to applications that exploit user-defined class loaders.
Tracing and reference counting are uniformly viewed as being fundamentally different approaches to garbage collection that possess very distinct performance properties. We have implemented high-performance collectors ...
详细信息
ISBN:
(纸本)1581138318
Tracing and reference counting are uniformly viewed as being fundamentally different approaches to garbage collection that possess very distinct performance properties. We have implemented high-performance collectors of both types, and in the process observed that the more we optimized them, the more similarly they behaved - that they seem to share some deep structure. We present a formulation of the two algorithms that shows that they are in fact duals of each other. Intuitively, the difference is that tracing operates on live objects, or "matter", while reference counting operates on dead objects, or "anti-matter". For every operation performed by the tracing collector, there is a precisely corresponding anti-operation performed by the reference counting collector. Using this framework, we show that all high-performance collectors (for example, deferred reference counting and generational collection) are in fact hybrids of tracing and reference counting. We develop a uniform cost-model for the collectors to quantify the trade-offs that result from choosing different hybridizations of tracing and reference counting. this allows the correct scheme to be selected based on system performance requirements and the expected properties of the target application.
this paper proposes and implements a rigorous method for studying the dynamic behaviour of AspectJ programs. As part of this methodology several new metrics specific to AspectJ programs are proposed and tools for coll...
详细信息
ISBN:
(纸本)1581138318
this paper proposes and implements a rigorous method for studying the dynamic behaviour of AspectJ programs. As part of this methodology several new metrics specific to AspectJ programs are proposed and tools for collecting the relevant metrics are presented. the major tools consist of: (1) a modified version of the AspectJ compiler that tags bytecode instructions with an indication of the cause of their generation, such as a particular feature of AspectJ;and (2) a modified version of the *J dynamic metrics collection tool which is composed of a JVMPI-based trace generator and an analyzer which propagates tags and computes the proposed metrics. this dynamic propagation is essential, and thus this paper contributes not only new metrics, but also non-trivial ways of computing them. We furthermore present a set of benchmarks that exercise a wide range of AspectJ's features, and the metrics that we measured on these benchmarks. the results provide guidance to AspectJ users on how to avoid efficiency pitfalls, to AspectJ implementors on promising areas for future optimization, and to tool builders on ways to understand the runtime behaviour of AspectJ.
Visualizing object interactions in an execution trace with a sequence diagram is a promising technique for helping developers to comprehend effectively the behavior of an object-oriented system. However, in most cases...
详细信息
this paper reports our experiences using traits, collections of pure methods designed to promote reuse and understandability in object-oriented programs. Traits had previously been used to refactor the Smalltalk colle...
详细信息
ISBN:
(纸本)1581138334
this paper reports our experiences using traits, collections of pure methods designed to promote reuse and understandability in object-oriented programs. Traits had previously been used to refactor the Smalltalk collection hierarchy, but only by the creators of traits themselves. this experience report represents the first independent test of these language features. Murphy-Hill implemented a substantial multi-class data structure called ropes that makes significant use of traits. We found that traits improved understandability and reduced the number of methods that needed to be written by 46%.
Large parts of today's software systems are devoted to detecting and recovering from failures, making exception handling a critical issue in software development. Concurrent software complicates this issue: most c...
详细信息
ISBN:
(纸本)9780769549224
Large parts of today's software systems are devoted to detecting and recovering from failures, making exception handling a critical issue in software development. Concurrent software complicates this issue: most concurrent programming languages require a mechanism to deal with asynchronous exceptions, but because of the diverse design choices underlying each language, no approach fits all situations. We introduce a classification of possible approaches to guide the development of asynchronous exception mechanisms, and we show its applicability by deriving a sound and comprehensible mechanism for SCOOP, an object-orientedprogramming model for concurrency. We describe the key idea of the mechanism using the accountability framework, which precisely defines the obligations of client and supplier regarding the reporting of exceptions. the framework not only provides the necessary intuition to apply the mechanism correctly, it is also useful to comprehend other approaches.
Inheritance is a useful mechanism for factoring and reusing code. However, it has limitations for building extensible systems. We describe nested inheritance, a mechanism that addresses some of the limitations of ordi...
详细信息
Inheritance is a useful mechanism for factoring and reusing code. However, it has limitations for building extensible systems. We describe nested inheritance, a mechanism that addresses some of the limitations of ordinary inheritance and other code reuse mechanisms. Using our experience with an extensible compiler framework, we show how nested inheritance can be used to construct highly extensible software frameworks. the essential aspects of nested inheritance are formalized in a simple object-oriented language with an operational semantics and type system. the type system of this language is sound, so no run-time type checking is required to implement it and no run-time type errors can occur. We describe our implementation of nested inheritance as an unobtrusive extension of the Java language, called Jx. Our prototype implementation translates Jx code to ordinary Java code, without duplicating inherited code.
the proceedings contains 119 papers from the 1997 IEEE 19th International conference on Software Engineering. Topics discussed include: Internet;formal specifications;software reliability;software inspection;user inte...
详细信息
the proceedings contains 119 papers from the 1997 IEEE 19th International conference on Software Engineering. Topics discussed include: Internet;formal specifications;software reliability;software inspection;user interfaces and specifications;legacy systems and testing;static analysis;metrics;software process improvement;reverse engineering and program understanding;C and C++ programming language analysis;object-orientedprogramming;reactive software specification testing;Java programming language;architecture recovery and reverse engineering;large scale architectures;software quality;collaborative software engineering;software evolution and maintenance;software interoperability;and Commercial-off-shelf software components.
暂无评论