Java Type Research Articles

Gem #57

In the preceding Ada/Java interfacing Gem, we saw how to create calls from Ada to Java using ada2java and callbacks. We're now going to go one step further, and discuss a cross-language dispatching mechanism that supports extension of an Ada tagged type in Java, allowing the possibility of making dispatching calls equally well from either side.

Java type inference is broken

Java 5, the most recent major update to the Java Programming Language, introduced a number of sophisticated features, including a major extension to the type system. While the technical details of these new features are complex, much of this complexity is hidden from the typical Java developer by an ambitious type inference mechanism. Unfortunately, the extensions to the Java 5 type system were so novel that their technical details had not yet been thoroughly investigated in the research literature. As a result, the Java 5 compiler includes a pragmatic but flawed type inference algorithm that is, by design, neither sound nor locally complete. The language specification points out that neither of these failures is catastrophic: the correctness of potentially-unsound results must be verified during type checking; and incompleteness can usually be worked around by manually providing the method type parameter bindings for a given call site. This paper dissects the type inference algorithm of Java 5 and proposes a signficant revision that is sound and able to calculate correct results where the Java 5 algorithm fails. The new algorithm is locally complete with the exception of a difficult corner case. Moreover, the new algorithm demonstrates that several arbitrary restrictions in the Java type system---most notably the ban on lower-bounded type parameter declarations and the limited expressibility of intersection types---are unnecessary. We hope that this work will spur the evolution of a more coherent, more comprehensive generic type system for Java.

On the reification of Java wildcards

Providing runtime information about generic types–that is, reifying generics–is a challenging problem studied in several research papers in the last years. This problem is not tackled in current version of the Java programming language (Java 6), which consequently suffers from serious safety and coherence problems. The quest for finding effective and efficient solutions to this problem is still open, and is further made more complicated by the new mechanism of wildcards introduced in Java J2SE 5.0: its reification aspects are currently unexplored and pose serious semantics and implementation issues. In this paper, we discuss an implementation support for wildcard types in Java. We first analyse the problem from an abstract viewpoint, discussing the issues that have to be faced in order to extend an existing reification technique so as to support wildcards, namely, subtyping, capture conversion and wildcards capture in method calls. Secondly, we present an implementation in the context of the EGO compiler. EGO is an approach for efficiently supporting runtime generics at compile-time: synthetic code is automatically added to the source code by the extended compiler, so as to create generic runtime type information on a by need basis, store it into object instances, and retrieve it when necessary in type-dependent operations. The solution discussed in this paper makes the EGO compiler the first reification approach entirely dealing with the present version of the Java programming language.

Species diversity, abundance, and vertical size structure of rattans in Borneo and Java

We studied rattan communities in four forest types in Borneo and Java to clarify the pattern of species diversity and vegetation structure. Within six plots of 4.82 ha in total, we found 42 rattan species in six genera with 4,736 stems (≥20 cm long). There was a significant positive correlation between rattans and trees in species diversity, decreasing in the order mixed dipterocarp (for rattans: Shannon–Wiener diversity index, H′ = 2.87–3.34) > alluvial (1.96) > lower montane (1.43) > peat swamp forests (1.34). This pattern coincided with the diversity of the regional flora. The density of rattan stems (ha–1) decreased in the order lower montane (5,997) > mixed dipterocarp (598–992) > alluvial (592) > peat swamp forests (162). The maximum height of rattans would be determined by the canopy height, rather than by the maximum tree height. The rattan stem volume ranged from 0.25 to 1.88 m3 ha−1 and was not correlated with the stem density. The cool montane climate seemed to decrease the maximum height of rattans, and a few small rattans made denser colonies. Swampy environments apparently suppressed the survival of non-climbing rattans strongly, but that of tall climbing rattans less so.

Type qualifier inference for java

Java's type system provides programmers with strong guarantees of type and memory safety, but there are many important properties not captured by standard Java types. We describe JQual, a tool that adds user-defined type qualifiers to Java, allowing programmers to quickly and easily incorporateextra lightweight, application-specific type checking into their programs. JQual provides type qualifier inference, so that programmers need only add a few key qualifier annotations to their program, and then JQual infers any remaining qualifiers and checks their consistency. We explore two applications of JQual. First, we introduce opaque and enumqualifiers to track C pointers and enumerations that flow through Java code via the JNI. In our benchmarks we found that these C values are treated correctly, but there are some places where a client could potentially violate safety. Second,we introduce a read only qualifier for annotating references that cannot be used to modify the objects they refer to. We found that JQual is able to automatically infer read only in many places on method signatures. These results suggest that type qualifiers and type qualifier inference are a useful addition to Java.

Static checking of dynamically generated queries in database applications

Many data-intensive applications dynamically construct queries in response to client requests and execute them. Java servlets, for example, can create strings that represent SQL queries and then send the queries, using JDBC, to a database server for execution. The servlet programmer enjoys static checking via Java's strong type system. However, the Java type system does little to check for possible errors in the dynamically generated SQL query strings. Thus, a type error in a generated selection query (e.g., comparing a string attribute with an integer) can result in an SQL runtime exception. Currently, such defects must be rooted out through careful testing, or (worse) might be found by customers at runtime. In this article, we present a sound , static program analysis technique to verify that dynamically generated query strings do not contain type errors. We describe our analysis technique and provide soundness results for our static analysis algorithm. We also describe the details of a prototype tool based on the algorithm and present several illustrative defects found in senior software-engineering student-team projects, online tutorial examples, and a real-world purchase order system written by one of the authors.

Runtime support for scalable programming in Java

The paper research is concerned with enabling parallel, high-performance computation--in particular development of scientific software in the network-aware programming language, Java. Traditionally, this kind of computing was done in Fortran. Arguably, Fortran is becoming a marginalized language, with limited economic incentive for vendors to produce modern development environments, optimizing compilers for new hardware, or other kinds of associated software expected of by today's programmers. Hence, Java looks like a very promising alternative for the future. The paper will discuss in detail a particular environment called HPJava. HPJava is the environment for parallel programming--especially data-parallel scientific programming--in Java. Our HPJava is based around a small set of language extensions designed to support parallel computation with distributed arrays, plus a set of communication libraries. A high-level communication API, Adlib, is developed as an application level communication library suitable for our HPJava. This communication library supports collective operations on distributed arrays. We include Java Object as one of the Adlib communication data types. So we fully support communication of intrinsic Java types, including primitive types, and Java object types.

Pluggable checking and inferencing of nonnull types for Java.

We have implemented a non-null type checker for Java and a new non-null inferencing algorithm for analyzing legacy code. The tools are modular extensions to the JastAdd extensible Java compiler, illustrating how pluggable type systems can be achieved. The resulting implementation is compact, less than 230 lines of code for the non-null checker and 460 for the inferencer. Non-null checking is a local analysis with little effect on compilation time. The inferencing algorithm is a whole-program analysis, yet it runs sufficiently fast for practical use, less than 10 seconds for 100.000 lines of code. We ran our inferencer on a large part of the JDK library, and could detect that around 70% of the dereferences, and around 24% of the method return values, were guaranteed to be non-null.

Authenticity control of essential oils containing citronellal and citral by chiral and stable-isotope gas-chromatographic analysis

Enantioselective capillary GC on a Supelco beta-DEX 225 column (heptakis(2,3-di-O-acetyl-6-O-tert-butyldimethylsilyl)-beta-cyclodextrin SPB 20poly--20% diphenyl, 80% dimethylsiloxane) and isotope-ratio mass spectrometry, coupled online with capillary GC on an HP5 column have been used for origin-specific analysis and authenticity control of essential oils, for example lemon (Citrus limon), lemongrass (Cymbopogon citratus and Cymbopogon flexuosus), citronella (Cymbopogon nardus L.--Ceylon type and Cymbopogon winterianus--Java type), Litsea cubeba, Lippia citriodora, lemon myrtle (Backhousia citriodora), lemon gum (Eucalyptus citriodora), and, especially, precious lemon balm oil (Melissa officinalis L.). Isotope data (delta13C(PDB) and delta2H(V-SMOW)) for citral (neral + geranial) and citronellal from on-line GC-C/Py-IRMS and chiral data for citronellal in these essential oils are reported. The possibility of using these data to determine the origin of these essential oils and to detect adulteration is discussed. Principal-components analysis (PCA) of specific compounds in two essential oils of lemongrass and Litsea cubeba was performed as a practical statistical method for distinguishing between these two types of oil.

Mapping Cobol Data to Java Type System with Functional Equivalence

Mapping Cobol Data to Java Type System with Functional Equivalence

Dynamic inference of polymorphic lock types

We present FindLocks, an approach for automatically proving the absence of data races in multi-threaded Java programs, using a combination of dynamic and static analysis. The program in question is instrumented so that when executed it will gather information about locking relationships. This information is then used to automatically generate annotations needed to type check the program using the Race-Free Java type system. Programs that type check are sure to be free from races. We call this technique dynamic annotation inference. We describe the design and implementation of our approach, and our experience applying the tool to a variety of Java programs. We have found that when using a reasonably comprehensive test suite, which is easy for small programs but harder for larger ones, the approach generates useful annotations.

Parametric polymorphism for Java

In spite of years of research toward a solution for the problem of extending Java with parametric polymorphism (genericity) the officially accepted solution already in its beta release allows violation of the Java type system and turns a type safe language into an unsafe one. The run-time type information in this release is incorrect which leads to major problems for the programmers relying on the Java reflective capabilities. We show that there are two basic reasons for these problems. The first one is that the idiom underlying this solution is provably incorrect. The second one is that the problem of extending Java with parametric polymorphism does not have a correct solution unless the Java Virtual Machine is extended to handle it properly. This paper elaborates the subtleties required by a correct implementation technique that includes representation of parametric classes in the standard Java class file format, representation of the instantiated parametric class objects, extensions of the Java Core Reflection to report type information about (instantiated) parametric classes, and the loading techniques required by this solution for extending Java with generics. Previous solutions for this problem are analyzed as well.

Refactoring Alloy Specifications

This paper proposes modeling laws for Alloy, a formal object-oriented modeling language. These laws are important not only to define the axiomatic semantics of Alloy but also to guide and formalize popular software development practices. In particular, these laws can be used to formaly refactor specifications. As an example, we formally refactor a specification for Java types.

Refactoring Alloy Specifications

This paper proposes modeling laws for Alloy, a formal object-oriented modeling language. These laws are important not only to define the axiomatic semantics of Alloy but also to guide and formalize popular software development practices. In particular, these laws can be used to formaly refactor specifications. As an example, we formally refactor a specification for Java types.

Verified bytecode verification and type-certifying compilation

This article presents a type certifying compiler for a subset of Java and proves the type correctness of the bytecode it generates in the proof assistant Isabelle. The proof is performed by defining a type compiler that emits a type certificate and by showing a correspondence between bytecode and the certificate which entails well-typing. The basis for this work is an extensive formalization of the Java bytecode type system, which is first presented in an abstract, lattice-theoretic setting and then instantiated to Java types.

Lightweight confinement for featherweight java

Confinement properties impose a structure on object graphs which can be used to enforce encapsulation properties essential to certain program optimizations, modular reasoning, and software assurance. This paper formalizes the notion of confined type in the context of Featherweight Java. A static type system that mirrors the informal rules of Grothoff et al [17] is proven sound. The definition of confined types is extended to confined instantiation of generic classes. This allows for confined collection types in Java and for classes that can be confined post hoc . Confinement type rules are given for Generic Featherweight Java, and proven sound.

Luna

Extensible Java systems face a difficult trade-off between sharing and protection. On one hand, Java's ability to run different protection domains in a single virtual machine enables domains to share data easily and communicate without address space switches. On the other hand, unrestricted sharing blurs the boundaries between protection domains, making it difficult to terminate domains and enforce restrictions on resource usage. Existing solutions to these problems restrict sharing in an ad-hoc fashion, ruling out many desirable programming styles.This paper presents an extension to Java's type system that systematically addresses the issues of data sharing, revocation, thread control, and resource control. Multiple tasks running in a single virtual machines share data using special remote pointers , which have different types from local pointers. The distinction between local and remote pointers allows the Java runtime system to mediate the communication between tasks without slowing down operations on ordinary pointers. The extensions to Java are implemented by a system called Luna, based on the Guavac and Marmot compilers, extended with special optimizations to support both fast inter-task communication and dynamic access control. The paper describes two applications written in Luna: a simple extensible web server, and an extension of the Squid web cache to support dynamic content generation.

Allozyme analysis of cryptic species in the Asplenium nidus complex from West Java, Indonesia

In various fern species, a large amount of rbcL sequence variation has been reported, and it is possible that these species contain several reproductively isolated cryptic species. In our previous study on Asplenium nidus L., it was suggested that the plants growing in Mt. Halimun National Park, West Java, Indonesia, consist of several cryptic species based on the results of crossing experiments among rbcL sequence types. In this study, we examined allozyme polymorphisms of five rbcL sequence types found in West Java in order to test the hypothesis that the assemblages of A. nidus delimited based on the rbcL sequences are separate Mendelian populations and gene flow is disrupted by reproductive isolation from one another. The calculated fixation indices suggested that the individuals in each rbcL type are randomly crossing at least in the investigated localities. Nevertheless, these rbcL-based assemblages were genetically differentiated in allozymes that are encoded in their nuclear genomes, and it is also suggested that gene flow is disrupted even between sympatrically distributed pairs of rbcL sequence types. Therefore, our findings support the view that the five rbcL sequence types in West Java are potential cryptic species.

Primitive types in Java considered harmful

Expression evaluation raises doubts about Java as an exemplar programming language when teaching the object-oriented paradigm.

Java access protection through typing

AbstractWe propose an integration of field access rights into the Java type system such that those access permission checks which are now performed dynamically (at run time), can instead be done statically, i.e. checked by the Java compiler and rechecked (at link time) by the bytecode verifier. We explain how this can be extended to remove all dynamic checks of field read access rights, completely eliminating the overhead of get methods for reading the value of a field. Improvements include using fast static lookup instead of dynamic dispatch for field access (without requiring a sophisticated inlining analysis), the space required by get methods is avoided, and denial‐of‐service attacks on field access is prevented. We sketch a formalization of adding field access to the bytecode verifier which will make it possible to prove that the change is safe and backwards compatible. Copyright © 2001 John Wiley & Sons, Ltd.