- Sponsor:
- sigplan
No abstract available.
Escape analysis for Java
This paper presents a simple and efficient data flow algorithm for escape analysis of objects in Java programs to determine (i) if an object can be allocated on the stack; (ii) if an object is accessed only by a single thread during its lifetime, so ...
Escape analysis for object-oriented languages: application to Java
Escape analysis [27, 14, 5] is a static analysis that determines whether the lifetime of data exceeds its static scope.
The main originality of our escape analysis is that it determines precisely the effect of assignments, which is necessary to apply it ...
Removing unnecessary synchronization in Java
Java programs perform many synchronization operations on data structures. Some of these synchronization are unnecessary; in particular, if an object is reachable only by a single thread, concurrent access is impossible and no synchronization is needed. ...
Detecting defects in object-oriented designs: using reading techniques to increase software quality
Inspections can be used to identify defects in software artifacts. In this way, inspection methods help to improve software quality, especially when used early in software development. Inspections of software design may be especially crucial since ...
A problem-oriented analysis of basic UML static requirements modeling concepts
The Unified Modeling Language (UML) is a standard modeling language in which some of the best object-oriented (OO) modeling experiences are embedded. In this paper we illustrate the role formal specification techniques can play in developing a precise ...
A language for specifying recursive traversals of object structures
We present a domain-specific language for specifying recursive traversals of object structures, for use with the visitor pattern. Traversals are traditionally specified as iterations, forcing the programmer to adopt an imperative style, or are hard-...
Confined types
Sharing and transfer of object references is difficult to control in object-oriented languages. Unconstrained sharing poses serious problems for writing secure components in object-oriented languages. In this paper, we present a set of inexpensive ...
Modular type-based reverse engineering of parameterized types in Java code
An analysis is provided for Java programs that reverse engineers parameterized types into existing Java code. This analysis propagates precise type information about the contents of container objects. As an application, the analysis can be used to ...
Semantic analysis of virtual classes and nested classes
Virtual classes and nested classes are distinguishing features of BETA. Nested classes originated from Simula, but until recently they have not been part of main stream object- oriented languages. C++ has a restricted form of nested classes and they ...
Featherweight Java: a minimal core calculus for Java and GJ
Several recent studies have introduced lightweight versions of Java: reduced languages in which complex features like threads and reflection are dropped to enable rigorous arguments about key properties such as type safety. We carry this process a step ...
A formal framework for the Java bytecode language and verifier
This paper presents a sound type system for a large subset of the Java bytecode language including classes, interfaces, constructors, methods, exceptions, and bytecode subroutines. This work serves as the foundation for developing a formal specification ...
Correspondence polymorphism for object-oriented languages
In this paper we propose a new form of polymorphism for object-oriented languages, called correspondence polymorphism. It lies in a different dimension than either parametric or subtype polymorphism. In correspondence polymorphism, some methods are ...
Compositional pointer and escape analysis for Java programs
This paper presents a combined pointer and escape analysis algorithm for Java programs. The algorithm is based on the abstraction of points-to escape graphs, which characterize how local variables and fields in objects refer to other objects. Each ...
An efficient meta-lock for implementing ubiquitous synchronization
Programs written in concurrent object-oriented languages, especially ones that employ thread-safe reusable class libraries, can execute synchronization operations (lock, notify, etc.) at an amazing rate. Unless implemented with utmost care, ...
A study of locking objects with bimodal fields
Object locking can be efficiently implemented by bimodal use of a field reserved in an object. The field is used as a lightweight lock in one mode, while it holds a reference to a heavyweight lock in the other mode. A bimodal locking algorithm recently ...
Efficient multiple and predicated dispatching
The speed of message dispatching is an important issue in the overall performance of object-oriented programs. We have developed an algorithm for constructing efficient dispatch functions that combines novel algorithms for efficient single dispatching, ...
Space and time-efficient memory layout for multiple inheritance
Traditional implementations of multiple inheritance bring about not only an overhead in terms of run-time but also a significant increase in object space. For example, the number of compiler-generated fields in a certain object can be as large as ...
Reducing transfer delay using Java class file splitting and prefetching
The proliferation of the Internet is fueling the development of mobile computing environments in which mobile code is executed on remote sites. In such environments, the end user must often wait while the mobile program is transferred from the server to ...
Practical experience with an application extractor for Java
Java programs are routinely transmitted over low-bandwidth network connections as compressed class file archives (i.e., zip files and jar files). Since archive size is directly proportional to download time, it is desirable for applications to be as ...
A performance evaluation of the mobile agent paradigm
This paper presents a performance evaluation of the mobile agent paradigm in comparison to the client/server paradigm. This evaluation has been conducted on top of the Java environment, using respectively RMI, the Aglets mobile agents platform and a ...
Implementing jalapeño in Java
- Bowen Alpern,
- C. R. Attanasio,
- Anthony Cocchi,
- Derek Lieber,
- Stephen Smith,
- Ton Ngo,
- John J. Barton,
- Susan Flynn Hummel,
- Janice C. Sheperd,
- Mark Mergen
Jalapeño is a virtual machine for Java™ servers written in Java.
A running Java program involves four layers of functionality: the user code, the virtual-machine, the operating system, and the hardware. By drawing the Java / non-Java boundary below the ...
Atlas: a case study in building a web-based learning environment using aspect-oriented programming
The Advanced Teaching and Learning Academic Server (Atlas) is a software system that supports web-based learning. Students can register for courses, and can navigate through personalized views of course material. Atlas has been built according to Sun ...
Role model designs and implementations with aspect-oriented programming
This paper describes research in applications of aspect-oriented programming (AOP) as captured in the AspectJ™ language. In particular, it compares object-oriented and aspect-oriented designs and implementations of role models.
Sections 1, 2, and 3 ...
Age-based garbage collection
Modern generational garbage collectors look for garbage among the young objects, because they have high mortality; however, these objects include the very youngest objects, which clearly are still live. We introduce new garbage collection algorithms, ...
Mostly-copying reachability-based orthogonal persistence
We describe how reachability-based orthogonal persistence can be supported even in uncooperative implementations of languages such as C++ and Modula-3, and without modification to the compiler. Our scheme extends Bartlett's mostly-copying garbage ...
The generic graph component library
In this paper we present the Generic Graph Component Library (GGCL), a generic programming framework for graph data structures and graph algorithms. Following the theme of the Standard Template Library (STL), the graph algorithms in GGCL do not depend ...
Zones, contracts and absorbing changes: an approach to software evolution
This paper describes a novel approach to managing the evolution of distributed, persistent systems at run-time. This is achieved by partitioning a system into disjoint zones, each of which can be evolved without affecting code in any other. Contracts ...
A distributed object-oriented framework for dependable multiparty interactions
In programming distributed object-oriented systems, there are several approaches for achieving binary interactions in a multiprocess environment. Usually these approaches take care only of synchronisation or communication. In this paper we describe a ...
Object views: language support for intelligent object caching in parallel and distributed computations
Object-based parallel and distributed applications are becoming increasingly popular, driven by the programmability advantages of component technology and a flat shared-object space. However, the flat shared-object space introduces a performance ...
Index Terms
- Proceedings of the 14th ACM SIGPLAN conference on Object-oriented programming, systems, languages, and applications
Recommendations
Acceptance Rates
Year | Submitted | Accepted | Rate |
---|---|---|---|
OOPSLA '14 | 186 | 52 | 28% |
OOPSLA '13 | 189 | 50 | 26% |
OOPSLA '09 | 144 | 25 | 17% |
OOPSLA '07 | 156 | 33 | 21% |
OOPSLA '03 | 147 | 26 | 18% |
OOPSLA '02 | 125 | 25 | 20% |
OOPSLA '01 | 145 | 27 | 19% |
OOPSLA '99 | 152 | 30 | 20% |
Overall | 1,244 | 268 | 22% |