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 s...
详细信息
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 relation to full Java as the lambda-calculus does to languages such as ML and Haskell. It offers a similar computational 'feel', providing classes, methods, fields, inheritance, and dynamic typecasts, with a semantics closely following Java's. A proof of type safety for Featherweight Java thus illustrates many of the interesting features of a safety proof for the full language, while remaining pleasingly compact. The syntax, type rules, and operational semantics of Featherweight Java fit on one page, making it easier to understand the consequences of extensions and variations. As an illustration of its utility in this regard, we extend Featherweight Java with generic classes in the style of GJ (Bracha, Odersky, Stoutamire, and Wadler) and sketch a proof of type safety. The extended system formalizes for the first time some of the key features of GJ.
The proceedings contain 37 papers. The topics discussed include: an evaluation of automatic object inline allocation techniques;JRes: a resource accounting interface for java;dynamic class loading in the java virtual ...
ISBN:
(纸本)1581132867
The proceedings contain 37 papers. The topics discussed include: an evaluation of automatic object inline allocation techniques;JRes: a resource accounting interface for java;dynamic class loading in the java virtual machine;object-oriented practice in 1998 (panel): does it help or hinder collaboration?;ownership types for flexible alias protection;borrow, copy or steal?: loans and larceny in the orthodox canonical form;safe metaclass programming;adaptive plug-and-play components for evolutionary software development;role model based framework design and integration;how to preserve the benefits of design patterns;data groups: specifying the modification of extended state;and a lambda calculus of objects with self-inflicted extension.
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 object...
详细信息
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 points-to escape graph also contains escape information, which characterizes how objects allocated in one region of the program can escape to be accessed by another region. The algorithm is designed to analyze arbitrary regions of complete or incomplete programs, obtaining complete information for objects that do not escape the analyzed regions. We have developed an implementation that uses the escape information to eliminate synchronization for objects that are accessed by only one thread and to allocate objects on the stack instead of in the heap. Our experimental results are encouraging. We were able to analyze programs tens of thousands of lines long. For our benchmark programs, our algorithms enable the elimination of between 24% and 67% of the synchronization operations. They also enable the stack allocation of between 22% and 95% of the objects.
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 m...
详细信息
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 design defects (problems of correctness and completeness with respect to the requirements, internal consistency, or other quality attributes) can directly affect the quality of, and effort required for, the implementation. We have created a set of 'reading techniques' (so called because they help a reviewer to 'read' a design artifact for the purpose of finding relevant information) that gives specific and practical guidance for identifying defects in object-oriented designs. Each reading technique in the family focuses the reviewer on some aspect of the design, with the goal that an inspection team applying the entire family should achieve a high degree of coverage of the design defects. In this paper, we present an overview of this new set of reading techniques. We discuss how some elements of these techniques are based on empirical results concerning an analogous set of reading techniques that supports defect detection in requirements documents. We present an initial empirical study that was run to assess the feasibility of these new techniques, and discuss the changes made to the latest version of the techniques based on the results of this study.
Jalapeno 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 ...
详细信息
Jalapeno 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 virtual machine rather than above it, Jalapeno reduces the boundary-crossing overhead and opens up more opportunities for optimization. To get Jalapeno started, a boot image of a working Jalapeno virtual machine is concocted and written to a file. Later, this file can be loaded into memory and executed. Because the boot image consists entirely of Java objects, it can be concocted by a Java program that runs in any JVM. This program uses reflection to convert the boot image into Jalapeno's object format. A special MAGIC class allows unsafe casts and direct access to the hardware. Methods of this class are recognized by Jalapeno's three compilers, which ignore their bytecodes and emit special-purpose machine code. User code will not be allowed to call MAGIC methods so Java's integrity is preserved. A small non-Java program is used to start up a boot image and as an interface to the operating system. Java's programming features - object orientation, type safety, automatic memory management - greatly facilitated development of Jalapeno. However, we also discovered some of the language's limitations.
deals with the reading, writing and understanding of specifications. The papers presented in this book describe useful and sometimes elegant concepts, good practices (in programming and in specifications), and sol...
详细信息
ISBN:
(数字)9781461552291
ISBN:
(纸本)9780792386292;9781461373834
deals with the reading, writing and understanding of specifications. The papers presented in this book describe useful and sometimes elegant concepts, good practices (in programming and in specifications), and solid underlying theory that is of interest and importance to those who deal with increased complexity of business and systems. Most concepts have been successfully used in actual industrial projects, while others are from the forefront of research. Authors include practitioners, business thinkers, academics and applied mathematicians. These seemingly different papers address different aspects of a single problem - taming complexity.;emphasizes simplicity and elegance in specifications without concentrating on particular methodologies, languages or tools. It shows how to handle complexity, and, specifically, how to succeed in understanding and specifying businesses and systems based upon precise and abstract concepts. It promotes reuse of such concepts, and of constructs based on them, without taking reuse for granted.;is the second volume of papers based on a series of workshops held alongside ACM's annual conference on object-orientedprogrammingsystemslanguages and applications (oopsla) and European conference on object-orientedprogramming (ECOOP). The first volume,;, edited by Haim Kilov and William Harvey, was published by Kluwer Academic Publishers in 1996.
暂无评论