Featherweight Java: a minimal core calculus for Java and GJ

@article{Igarashi2001FeatherweightJA,
  title={Featherweight Java: a minimal core calculus for Java and GJ},
  author={Atsushi Igarashi and Benjamin C. Pierce and Philip Wadler},
  journal={ACM Trans. Program. Lang. Syst.},
  year={2001},
  volume={23},
  pages={396-450}
}
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 further, omitting almost all features of the full language (including interfaces and even assignment) to obtain a small calculus, Featherweight Java, for which rigorous proofs are not only possible but easy. Featherweight Java bears a similar… 

Figures from this paper

An Inherently-Typed Formalization for Featherweight Java
TLDR
An inherently-typed approach to formalize Featherweight Java is explored, implementing the static and dynamic semantics in Agda using dependent types, and then replicating it in Coq (the latter using the Equations plug-in).
A Featherweight Calculus for Flow-Sensitive Type Systems in Java
TLDR
This paper formalises the syntax, semantics, and typing process of FIJ, an imperative formalisation of Java that provides support for control-flow arising from exceptions and what it means for a FIJ program to be type-safe.
Welterweight Java
TLDR
Welterweight Java is presented, a new minimal core Java calculus intended to be a suitable starting point for investigations in the semantics of Java-like programs and illustrates the potential of the calculus by showing two extensions.
a modest extension of Featherweight Java
TLDR
This work introduces FeatherTrait Java (FTJ), a conservative extension of the simple lightweight class-based calculus Featherweight Java with statically-typed traits, and presents an operational semantics with a lookup algorithm, and a sound type system that guarantees that evaluating a well-typing expression never yields a message-not-understood run-time error nor gets the interpreter stuck.
JavaGI: The Interaction of Type Classes with Interfaces and Inheritance
TLDR
This article formalizes a core calculus for JavaGI and proves type soundness, decidability of typechecking, and determinacy of evaluation and presents the implementation of a JavaGI compiler and an accompanying run-time system.
Lifted Java: A Minimal Calculus for Translation Polymorphism
TLDR
This paper presents a simple model that extends Featherweight Java with the core operations of translation polymorphism, provides a Coq proof that its type system is sound, and shows that the ambiguity problem associated with the so-called smart lifting mechanism can be eliminated by a very simple semantics for lifting.
Mechanization and overhaul of feature featherweight Java
TLDR
This work details some design decisions related to the process of specifying Featherweight Java (FJ) in Coq and thus evolving such a speci cation to prove the type system properties of an revised version of Feature Featherweights Java (FFJ), a core-calculus for a family of languages that address variability management in highly con gurable systems.
FeatherTrait: A modest extension of Featherweight Java
TLDR
This work introduces FeatherTrait Java (FTJ), a conservative extension of the simple lightweight class-based calculus Featherweight Java (FJ) with statically typed traits, and presents an operational semantics with a lookup algorithm, and a sound type system that guarantees that evaluating a well-typed expression never yields a message-not-understood run-time error nor gets the interpreter stuck.
Properties of Java Simple Closures
TLDR
A minimal calculus is defined: Featherweight Java extended with Simple Closures and Syntax and semantics of such a calculus are defined and type safety, backward compatibility, and the abstraction property are proved.
...
...

References

SHOWING 1-10 OF 53 REFERENCES
Compatible genericity with run-time types for the Java programming language
TLDR
This paper explains how to support general type parameterization---including both non-variant and covariant subtyping---on top of the existing Java Virtual Machine at the cost of a larger code footprint and the forwarding of some method calls involving parameterized classes and methods.
Type-preserving compilation of featherweight java
  • C. LeagueZhong ShaoV. Trifonov
  • Computer Science
    Foundations of Intrusion Tolerant Systems, 2003 [Organically Assured and Survivable Information Systems]
  • 2003
TLDR
This work provides a foundation for supporting certifying compilation of Java-like class-based languages in a type-theoretic framework and extends naturally to a significant subset of Java, including interfaces and privacy.
Proving Java Type Soundness
  • Don Syme
  • Computer Science
    Formal Syntax and Semantics of Java
  • 1999
TLDR
This chapter describes a machine checked proof of the type soundness of a subset of Java (the authors call this subset JavaS) that complements the written semantics by correcting and clarifying some details and demonstrates the utility of formal, machine checking when exploring a large and detailed proof based on operational semantics.
A Recipe for Raw Types
The design of GJ (Bracha, Odersky, Stoutamire and Wadler), an extension of Java with parametric polymorphism, was significantly affected by the issue of compatibility between legacy Java code and new
True Modules for Java-like Languages
TLDR
JAVAMOD is a module language which is extremely flexible and allows to express, for instance, generic types as in Pizza and GJ, mixin classes (that is, subclasses parametric in the direct superclass) and mutually recursive class definitions split in independent modules.
Parameterized types for Java
TLDR
The rationale for the design decisions and the impact of the extension on other parts of Java, including arrays and the class library are discussed, and optional extensions to the Java virtual machine to allow parameterized bytecodes are described, and how to verify them efficiently.
A Syntactic Approach to Type Soundness
TLDR
A new approach to proving type soundness for Hindley/Milner-style polymorphic type systems by an adaptation of subject reduction theorems from combinatory logic to programming languages and the use of rewriting techniques for the specification of the language semantics is presented.
Parametric polymorphism in Java: an approach to translation based on reflective features
TLDR
This paper introduces a homogeneous translation in which run-time information about instantiation of type-parameters is carried, allowing full integration of parame-terized types with Java typing.
Is the Java Type System Sound?
TLDR
This work argues that for this subset of Java describing primitive types, classes, inheritance, instance variables and methods, interfaces, shadowing, dynamic method binding, object creation, null, arrays, and exception throwing and handling the type system is sound, by proving that program execution preserves the types, up to subclasses/subinterfaces.
A Programmer's Reduction Semantics for Classes and Mixins
TLDR
A model of class-to-class functions that refers to as mixins is developed, which is an intuitive model of an essential Java subset; an extension that explains and models mixins; and type soundness theorems for these languages.
...
...