• Documents
  • Authors
  • Tables
  • Log in
  • Sign up
  • MetaCart
  • DMCA
  • Donate

CiteSeerX logo

Advanced Search Include Citations
Advanced Search Include Citations

P.: Featherweight Java: A minimal core calculus for Java and (1999)

by A Igarashi, B Pierce, Wadler
Add To MetaCart

Tools

Sorted by:
Results 1 - 10 of 659
Next 10 →

Alias Annotations for Program Understanding

by Jonathan Aldrich, Valentin Kostadinov, Craig Chambers - In Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA , 2002
"... One of the primary challenges in building and evolving large object-oriented systems is dealing with aliasing between objects. Unexpected aliasing can lead to broken invariants, mistaken assumptions, security holes, and surprising side effects, all of which may lead to software defects and complicat ..."
Abstract - Cited by 201 (12 self) - Add to MetaCart
One of the primary challenges in building and evolving large object-oriented systems is dealing with aliasing between objects. Unexpected aliasing can lead to broken invariants, mistaken assumptions, security holes, and surprising side effects, all of which may lead to software defects and complicate software evolution.

An Overview of the Scala Programming Language

by Martin Odersky, Stéphane Micheloud, Nikolay Mihaylov, Michel Schinz, Erik Stenman, Matthias Zenger, et al. , 2004
"... Scala provides a fusion between object-oriented and functional programming in a statically typed programming language. It is aimed at the construction of components and component systems. This paper gives an overview of the Scala language for readers who are familar with programming methods and prog ..."
Abstract - Cited by 146 (8 self) - Add to MetaCart
Scala provides a fusion between object-oriented and functional programming in a statically typed programming language. It is aimed at the construction of components and component systems. This paper gives an overview of the Scala language for readers who are familar with programming methods and programming language design.

PolyTOIL: A type-safe polymorphic object-oriented language

by Kim B. Bruce, Adrian Fiech, Angela Schuett, Robert Van Gent , 1995
"... PolyTOIL is a new statically-typed polymorphic object-oriented programming language that is provably type-safe. By separating the de nitions of subtyping and inheritance, providing a name for the type of self, and carefully de ning the type-checking rules, we have obtained a language that is ve ..."
Abstract - Cited by 140 (10 self) - Add to MetaCart
PolyTOIL is a new statically-typed polymorphic object-oriented programming language that is provably type-safe. By separating the de nitions of subtyping and inheritance, providing a name for the type of self, and carefully de ning the type-checking rules, we have obtained a language that is very expressive while supporting modular type-checking of classes. The matching relation on types, which is related to F-bounded quanti cation, is used both in stating type-checking rules and expressing the bounds on type parameters for polymorphism. The design of PolyTOIL is based on a careful formal de nition of type-checking rules and semantics.

Ownership Domains: Separating Aliasing Policy from Mechanism

by Jonathan Aldrich, Craig Chambers , 2004
"... Ownership types promise to provide a practical mechanism for enforcing stronger encapsulation by controlling aliasing in objectoriented languages. However, previous ownership type proposals have tied the aliasing policy of a system to the mechanism of ownership. As a result, these proposals are too ..."
Abstract - Cited by 134 (13 self) - Add to MetaCart
Ownership types promise to provide a practical mechanism for enforcing stronger encapsulation by controlling aliasing in objectoriented languages. However, previous ownership type proposals have tied the aliasing policy of a system to the mechanism of ownership. As a result, these proposals are too weak to express many important aliasing constraints, yet also so restrictive that they prohibit many useful programming idioms. In this paper, we propose ownership domains, which decouple encapsulation policy from the mechanism of ownership in two key ways. First, developers can specify multiple ownership domains for each object, permitting a fine-grained control of aliasing compared to systems that provide only one ownership domain for each object. Second, developers can specify the permitted aliasing between each pair of domains in the system, providing more flexibility compared to systems that enforce a fixed policy for inter-domain aliasing. Because it decouples policy from mechanism, our alias control system is both more precise and more flexible than previous ownership type systems.
(Show Context)

Citation Context

...ownership domains in the open-source AliasJava compiler [4], which is freely available at http://www.archjava.org/. Section 3 presents our proposal more formally as an extension of Featherweight Java =-=[18]-=-, and proves that our type system enforces the aliasing specifications given by the programmer. Section 4 discusses related work, and Section 5 concludes. 2 Ownership Domains We illustrate ownership d...

A machine-checked model for a Java-like language, virtual machine and compiler

by Gerwin Klein, Tobias Nipkow - ACM TRANSACTIONS ON PROGRAMMING LANGUAGES AND SYSTEMS , 2004
"... We introduce Jinja, a Java-like programming language with a formal semantics designed to exhibit core features of the Java language architecture. Jinja is a compromise between realism of the language and tractability and clarity of the formal semantics. The following aspects are formalised: a big an ..."
Abstract - Cited by 126 (9 self) - Add to MetaCart
We introduce Jinja, a Java-like programming language with a formal semantics designed to exhibit core features of the Java language architecture. Jinja is a compromise between realism of the language and tractability and clarity of the formal semantics. The following aspects are formalised: a big and a small step operational semantics for Jinja and a proof of their equivalence; a type system and a definite initialisation analysis; a type safety proof of the small step semantics; a virtual machine (JVM), its operational semantics and its type system; a type safety proof for the JVM; a bytecode verifier, i.e. data flow analyser for the JVM; a correctness proof of the bytecode verifier w.r.t. the type system; a compiler and a proof that it preserves semantics and well-typedness. The emphasis of this work is not on particular language features but on providing a unified model of the source language, the virtual machine and the compiler. The whole development has been carried out in the theorem prover Isabelle/HOL.
(Show Context)

Citation Context

...ry subtle interactions between type system and exceptions. Schirmer [2003a] has analysed the interaction of packages and access modifiers. On the other end of the spectrum we have Featherweight Java [=-=Igarashi et al. 2001-=-], a minimal subset of Java which was used to study type soundness proofs. On the borderline to program verification we have the denotational semantics of Java by Huisman [2001]. Further aspects forma...

The Verifying Compiler: a Grand Challenge for Computer Research,

by Tony Hoare - JACM , 2003
"... Abstract. I propose a set of criteria which distinguish a grand challenge in science or engineering from the many other kinds of short-term or long-term research problems that engage the interest of scientists and engineers. As an example drawn from Computer Science, I revive an old challenge: the ..."
Abstract - Cited by 118 (2 self) - Add to MetaCart
Abstract. I propose a set of criteria which distinguish a grand challenge in science or engineering from the many other kinds of short-term or long-term research problems that engage the interest of scientists and engineers. As an example drawn from Computer Science, I revive an old challenge: the construction and application of a verifying compiler that guarantees correctness of a program before running it.
(Show Context)

Citation Context

...facilitate program verification. However, the relevant concepts of concurrency and objects have been explored by theoreticians in the ‘clean room’ conditions of new experimental programming languages =-=[17,18]-=-. In the implementation of a verifying compiler, the results of such pure research will have to be adapted, extended and combined; they must then be implemented and tested by application on a broad sc...

Secure Information Flow and Pointer Confinement in a Java-like Language

by Anindya Banerjee, David A. Naumann - In IEEE Computer Security Foundations Workshop (CSFW , 2002
"... We consider a sequential object-oriented language with pointers and mutable state, private fields and classbased visibility, dynamic binding and inheritance, recursive classes, casts and type tests, and recursive methods. Programs are annotated with security levels, constrained by security typing ru ..."
Abstract - Cited by 113 (14 self) - Add to MetaCart
We consider a sequential object-oriented language with pointers and mutable state, private fields and classbased visibility, dynamic binding and inheritance, recursive classes, casts and type tests, and recursive methods. Programs are annotated with security levels, constrained by security typing rules. A noninterference theorem shows how the rules ensure pointer confinement and secure information flow.

Safe composition of product lines

by Don Batory, Sahil Thaker - GENERATIVE PROGRAMMING AND COMPONENT ENGINEERING, 6TH INTERNATIONAL CONFERENCE (GPCE 2007) , 2007
"... Programs of a software product line can be synthesized by composing modules that implement features. Besides high-level domain constraints that govern the compatibility of features, there are also low-level implementation constraints: a feature module can reference classes that are defined in other ..."
Abstract - Cited by 110 (12 self) - Add to MetaCart
Programs of a software product line can be synthesized by composing modules that implement features. Besides high-level domain constraints that govern the compatibility of features, there are also low-level implementation constraints: a feature module can reference classes that are defined in other feature modules. Safe composition is the guarantee that programs composed from feature modules are absent of references to undefined classes, methods, and variables. We show how safe composition can be

A Nominal Theory of Objects with Dependent Types

by Martin Odersky, Vincent Cremet, Christine Röckl, Matthias Zenger - In Proc. ECOOP’03, Springer LNCS , 2002
"... We design and study νObj, a calculus and dependent type system for objects and classes which can have types as members. Type members can be aliases, abstract types, or new types. The type system can model the essential concepts of Java's inner classes as well as virtual types and family ..."
Abstract - Cited by 109 (19 self) - Add to MetaCart
We design and study νObj, a calculus and dependent type system for objects and classes which can have types as members. Type members can be aliases, abstract types, or new types. The type system can model the essential concepts of Java's inner classes as well as virtual types and family polymorphism found in BETA or gbeta. It can also model most concepts of SML-style module systems, including sharing constraints and higher-order functors, but excluding applicative functors. The type system can thus...
(Show Context)

Citation Context

...ge reduces to an answer of the same type. Other related work This paper extends a previous workshop contribution [35]. Nominal type systems have also been formalized in the Java context, examples are =-=[21,27,32]-=-. A difference between these approaches and ours is that they rely on a global class graph that describes membership and inheritance. Another difference is that these systems are almost completely nom...

Safe futures for Java

by Adam Welc, Suresh Jagannathan, Antony Hosking - In Proceedings of the 20th Annual ACM SIGPLAN Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA 2005). ACM , 2005
"... A future is a simple and elegant abstraction that allows concurrency to be expressed often through a relatively small rewrite of a sequential program. In the absence of side-effects, futures serve as benign annotations that mark potentially concurrent regions of code. Unfortunately, when computation ..."
Abstract - Cited by 96 (7 self) - Add to MetaCart
A future is a simple and elegant abstraction that allows concurrency to be expressed often through a relatively small rewrite of a sequential program. In the absence of side-effects, futures serve as benign annotations that mark potentially concurrent regions of code. Unfortunately, when computation relies heavily on mutation as is the case in Java, its meaning is less clear, and much of its intended simplicity lost. This paper explores the definition and implementation of safe futures for Java. One can think of safe futures as truly transparent annotations on method calls, which designate opportunities for concurrency. Serial programs can be made concurrent simply by replacing standard method calls with future invocations. Most significantly, even though some parts of the program are executed concurrently and may indeed operate on shared data, the semblance of serial execution is nonetheless preserved. Thus, program reasoning is simplified since data dependencies present in a sequential program are not violated in a version augmented with safe futures. Besides presenting a programming model and API for safe futures, we formalize the safety conditions that must be satisfied to ensure equivalence between a sequential Java program and its futureannotated counterpart. A detailed implementation study is also provided. Our implementation exploits techniques such as object versioning and task revocation to guarantee necessary safety conditions. We also present an extensive experimental evaluation of our implementation to quantify overheads and limitations. Our experiments indicate that for programs with modest mutation rates on shared data, applications can use futures to profitably exploit parallelism, without sacrificing safety.
Powered by: Apache Solr
  • About CiteSeerX
  • Submit and Index Documents
  • Privacy Policy
  • Help
  • Data
  • Source
  • Contact Us

Developed at and hosted by The College of Information Sciences and Technology

© 2007-2019 The Pennsylvania State University