Showing papers on "Java API for XML-based RPC published in 1999"

Implementing jalapeño in Java

Abstract: 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.

A more efficient RMI for Java

Abstract: In current Java implementations, Flemote Method Invocation (RMI) is too slow, especially for high performance computing. RMI is designed for wide-area and high-latency networks, it is based on a slow object serialization, and it does not support high-performance communication networks. The paper demonstrates that a much faster drop-in RMI and an efficient serialization can be designed and implemented completely in Java without any native code. Moreover, the re-designed RMI supports non-TCP/IP communication networks, even with heterogeneous transport protocols. As a by-product,, a benchmark collection for RMI is presented. This collection asked -for by the Java Grande Forum from its first meeting can guide JVM vendors in their performance optimizations. On PCs connected through Ethernet, the better serialization and the improved RMI save a median of 45% (maximum of 71%) of the runtime for :some set of arguments. On our Myrinet-based ParaStation network (a cluster of DEC Alphas) we save a median of 85% (maximum of 96%), compared to standard RMI, standard serialization, and Fast Ethernet; a remote method invocation runs as fast as 115 /.s round trip time, compared to about 1.5 ms.

Securing Java: getting down to business with mobile code

Abstract: Mobile Code and Security: Why Java Security Is Important The Base Java Security Model: The Original Applet Sandbox Beyond the Sandbox: Signed Code and Java 2 Malicious Applets: Avoiding a Common Nuisance Attack Applets: Exploiting Holes in the Security Model Securing Java: Improvements, Solutions, and Snake Oil Java Security Guidelines: Developing and Using Java More Securely Java Card Security: How Smart Cards and Java Mix The Future of Java Security: Challenges Facing Mobile Code Appendices References Index.

User authentication and authorization in the Java/sup TM/ platform

Abstract: Java/sup TM/ security technology originally focused on creating a safe environment in which to run potentially untrusted code downloaded from the public network. With the latest release of the Java/sup TM/ platform (the Java/sup TM/ 2 Software Development Kit, v 1.2), fine-grained access controls can be placed upon critical resources with regard to the identity of the running applets and applications, which are distinguished by where the code came from and who signed it. However, the Java platform still lacks the means to enforce access controls based on the identity of the user who runs the code. In this paper we describe the design and implementation of the Java/sup TM/ Authentication and Authorization Service (JAAS), a framework and programming interface that augments the Java/sup TM/ platform with both user-based authentication and access control capabilities.

Java PathFinder, A Translator from Java to Promela

Abstract: Java PathFinder [2], Jpf, is a prototype translator from Java to Promela, the modeling language of the Spin model checker [4]. Jpf is a product of a major effort by the Automated Software Engineering group at NASA Ames to make model checking technology part of the software process. Experience has shown that severe bugs can be found in final code using this technique [1], and that automated translation from a programming language to a modeling language like Promela can help reducing the effort required.

XML and Java: Developing Web Applications

Abstract: From the Publisher: XML and Java : Developing Web Applications is a tutorial that will teach Web developers, programmers, and system engineers how to create robust XML business applications for the Internet using the Java technology. Readers should have a basic understanding of XML as well as experience in writing simple Java programs.

A Simple Extension of Java Language for Controllable Transparent Migration and Its Portable Implementation

Abstract: A scheme has been developed that enables a Java program to be migrated across computers while preserving its execution state, such as the values of local variables and the dynamic extents of try-and-catch blocks This scheme provides the programmer with flexible control of migration, including transparent migration It is based on source-code-level transformation The translator takes as input code a Java program written in a Java language extended with language constructs for migration, and outputs pure Java source code that uses JavaRMI The translated code can run on any Java interpreter and can be compiled by any just-in-time compiler We have measured some execution performance for several application programs, and found that the translated programs are only about 20% slower than the original programs Because migration is completely controlled by using only three language constructs added to the Java language (go, undock and migratory), the programmer can write programs to be migrated easily and succinctly Our system is available in the public domain

Java annotation-aware just-in-time (AJIT) complilation system

Abstract: The Java Bytecode language lacks expressiveness for traditional compiler optimizations,making this portable, secure software distribution format ine cient as a program representation for high performance. This ine ciency results from the underlying stack model, as well as the fact that many bytecode operations intrinsically include sub-operations (e.g., iaload includes the address computation, array bounds checks and the actual load of the array element). The stack model, with no operand registers and limiting access to the top of the stack, prevents the reuse of values and bytecode reordering. In addition, the bytecodes have no mechanism to indicate which sub-operations in the bytecode stream are redundant or subsumed by previous ones. As a consequence, the Java Bytecode language inhibits the expression of important compiler optimizations, including common sub-expression elimination, register allocation and instruction scheduling. The bytecode stream generated by the Java frontend is a signi cantly under-optimized program representation. The most common solution to overcome this aspect of the language is the use of a Just-in-Time (JIT) compiler to not only generate native code, but perform optimization as well. However, the latter is a time consuming operation in an already time-constrained translation process. In this paper we present an alternative to an optimizing JIT compiler that makes use of code annotations generated by the Java front-end. These annotations carry information concerning compiler optimization. During the translation process, an annotationaware JIT (AJIT) system then uses this information to produce high-performance native code without perThis work supported in part by CAPES. forming much of the necessary analyses or transformations. We describe the implementation of the rst prototype of our annotation-aware JIT system and show performance results comparing our system with other Java Virtual Machines (JVMs) running on SPARC architecture.

From Dalang to Kava - The Evolution of a Reflective Java Extension

Abstract: Current implementations of reflective Java extensions typically either require access to source code, or require a modified Java platform. This makes them unsuitable for applying reflection to Commercial-off-the-Shelf (COTS) systems. In order to address this we developed a prototype Java extension Dalang based on class wrapping that worked with compiled code, and was implemented using a standard Java platform. In this paper we evaluate the class wrapper approach, and discuss issues that relate to the transparent application of reflection to COTS systems. This has informed our design of a new version of Dalang called Kava that implements a metaobject protocol through the application of standard byte code transformations. Kava leverages the capabilities of byte code transformation toolkits whilst presenting a high-level abstraction for specifying behavioural changes to Java components.

The Java Language

Abstract: The Java programming language is similar to the C++ language - but with some interesting differences. If you are a C++ expert you will be able to zip through this chapter quite fast - chapter 15 deals specifically with the differences between the two languages. If you have used a high level language such as Pascal before you will also find the switch to Java straightforward.

Chava: reverse engineering and tracking of Java applets

Abstract: Java applets have been used increasingly on Web sites to perform client-side processing and provide dynamic content. While many Web site analysis tools are available, their focus has been on static HTML content and most ignore applet code completely. The paper presents Chava, a system that analyzes and tracks changes in Java applets. The tool extracts information from applet code about classes, methods, fields and their relationships into a relational database. Supplementary checksum information in the database is used to detect changes in two versions of a Java applet. Given our Java data model, a suite of programs that query, visualize, and analyze the structural information were generated automatically from CIAO, a retargetable reverse engineering system. Chava is able to process either Java source files or compiled class files, making it possible to analyze remote applets, whose source code is unavailable. The information can be combined with HTML analysis tools to track both the static and dynamic content of many Web sites. The paper presents our data model for Java and describes the implementation of Chava. Advanced reverse engineering tasks such as reachability analysis, clustering, and program differencing can be built on top of Chava to support design recovery and selective regression testing. In particular, we show how Chava is used to compare several Java Development Kit (JDK) versions to help spot changes that might impact Java developers. Performance numbers indicate that the tool scales well.

Applying Model Checking in Java Verification

Abstract: This paper presents our experiences in applying the Java PathFinder (Jpf), a recently developed Java to Promela translator, in the search for synchronization bugs in a Chinese Chess game server application written in Java. We give an overview of Jpf and the subset of Java that it supports and describe an initial effort to abstract and analyze the game server. Finally, we evaluate the results of the effort.

TV pip using java api classes and java implementation classes

Abstract: A method and apparatus in which the appearance and functionality of a virtual remote control panel on a web page is controlled by an applet downloaded in connection with the web page. Because the appearance and functionality of the virtual control panel is controlled by the applet, it is easy to change. The invention also includes a set of methods or functions (an API) that can be used by the applet to interface to the video source. This API uses a PIP abstract Java class and a PIPInfo abstract Java class, where "PIP" stands for "picture in picture."

Harissa: A hybrid approach to Java execution

Abstract: Java provides portability and safety but falls short on efficiency. To resolve this problem, the authors developed Harissa, an execution environment that offers efficiency without sacrificing portability or dynamic class loading.

A ubiquitous message passing interface implementation in Java:jmpi

Abstract: jmpi is a 100% Java-based implementation of the message-passing interface (MPI-1) standard jmpi comes with an efficient and effective MPI implementation in Java and supports a user-friendly Java application programming interface (API) for MPI. We present the implementation details and give some early communication benchmark performance results on a cluster of SUN UltraSparc workstations.

Modular type-based reverse engineering of parameterized types in Java code

Abstract: 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 justify the safe removal of downcasts that are guaranteed to succeed. Another application is in automatically reverse engineering parameterized types into existing Java libraries, so that they can be used in Java dialects with parameterized types.

Distributed programming with Java

Abstract: For programmers who are already familiar with Java, this book offers new techniques on how to develop distributed applications.

Transparent communication for distributed objects in Java

Abstract: We describe a native-code implementation of Java that supports distributed objects. In order to foster the correctness of distributed programs, remote access is syntactically and semantically indistinguishable from local access. This transparency is provided by the runtime system through the implicit generation of remote references to an object when it is passed as an argument or returned from a remote method call. Consistency is achieved through the use of a distributed (and thus scalable) global addressing scheme. Experiments show that application performance is a function of data layout, access algorithm, and local workload. For distributed applications, such as distributed databases, these factors may not be known statically, suggesting the importance of runtime support.

Interoperability and interchangeability of middleware components in a three-tier CORBA-environment-state of the art

Abstract: The paper covers heterogeneous multi-tier environments based on CORBA and Java. On the client side there is a Web browser that connects to the middle tier through CORBA-based Java applets. The business logic is decoupled from the database server on the third tier. Access to the databases is made through a JDBC interface or with embedded SQL. We present considerations about the use of different browsers and multiple ORBs, concentrating on interoperability issues. We explore the problems that have to be faced and give practical advice on how to make things work.

Java foundation classes in a nutshell

Abstract: From the Publisher: Java Foundation Classes in a Nutshell is a quick reference for Java programmers who are writing applications that use graphics or graphical user interfaces. The author has written introductions to the Java APIs that comprise the Java Foundation Classes (JFC), so you can start using these new technologies right away. This book contains an overview of the architecture of graphical user interfaces built with both the new Swing API and the older AWT; an introduction to the important components and application services provided by the Swing API; and a comprehensive explanation of the features of the new Java 2D API.

Behavioural specification using XML

Abstract: Active networks are an example of a wide area distributed system. The objects in this system require platform independent machine-readable, flexible behaviour specifications. Current mechanisms in CORBA, DCOM and similar technologies are not adequate. We demonstrate for the first time how specifications with the required properties can be written in XML, the new language of the WWW.

CS1 using Java language features gently

Abstract: Teaching a new programming language in CS1 requires the instructor to make several important decisions regarding sequencing of topics. In teaching Java, the basic decisions center around how to perform input and output, when to teach the AWT (Abstract Window Toolkit) and threads, whether to begin with applets or applications, and how much detail about object-oriented programming and Java language features is required in the beginning. This paper describes a "language features gently" approach to teaching CS1 in Java.

The Operational Semantics of a Java Secure Processor

Abstract: A formal specification of a Java Secure Processor is presented, which is mechanically checked for type consistency, well formed-ness and operational conservativity. The specification is executable and it is used to animate and study the behaviour of sample Java programs. The purpose of the semantics is to document the behaviour of the complete JSP for the benefit of implementors.

Method and system for accessing java applications

Abstract: Java methods contained in a Java class and method database are accessed by a non-Java application running on a local machine or a remote machine The non-Java application generates a standard TCP/IP communication call for a method of a Java class in the database A Java service server running on a Java VM on the local machine receives the method call and related parameter data and performs their processing including a conversion of the call and of related parameter data from a transport format into Java native data types The converted data is used for invoking a Java method for execution by applying the method to the converted parameter data The result data of the method execution is converted from the Java format into the transport format in which they are transmitted to the non-Java application

Schema for Representing Java(tm) Objects in an LDAP Directory

Abstract: This document defines the schema for representing Java(tm) objects in an LDAP directory [LDAPv3]. It defines schema elements to represent a Java serialized object [Serial], a Java marshalled object [RMI], a Java remote object [RMI], and a JNDI reference [JNDI].

A Practical Approach for Improving Startup Latency in Java Applications

Abstract: In emerging application domains, such as thin client computing and hypertext systems with embedded objects (e.g. the World Wide Web), the process of downloading application code is in the critical path of users. We observe that in these domains, compliance with existing standards and minimizing the impact on the clients is crucial. We argue that the fundamental problem for mobile code is that the units of code distribution in networked object systems, such as Java, are not suited for efficient utilization of network bottlenecks. In this paper, we propose a separate optimization step, between compilation and loading, whereby application code is restructured to more effectively use the available network bandwidth for program download. We have designed and implemented such an optimization step as a binary rewriting service for Java applets and applications. Our implementation does not require any modifications to existing Java virtual machines, compilers or clients. We have found that restructuring of Java applications can improve program startup times by up to 30%.

Ready-to-Run Java 3D

Abstract: Getting Started A 3D Graphics Primer Meet the Java 3D API Beautiful Geometry Translation, Rotation, and Scaling Light and Transparency Behaviors, Interpolators, and Event Detection Fog Effects Texture Mapping Java 3D Sound 3D Text and Fonts Java 3D Web Tools and Utilities Appendices Index.

XNAMI-an extensible XML-based paradigm for network and application management instrumentation

Abstract: We introduce a new paradigm for the retrieval and presentation of management data. XNAMI is a Java-based network and application management toolkit which uses XML and the document object model to specify a management information base (MIB) at runtime. This approach allows the MIB to be serialized and shipped over the network between managers and agents. It also facilitates runtime agent extension and allows the MIB to be easily browsed and seamlessly integrated with online documentation. XML further allows for the interchange of data between management applications using different information models.

Exception Analysis for Java

Abstract: Current JDK Java compiler relies too much on programmer's speciication for checking against uncaught exceptions of the input program. It is not elaborate enough to remove programmer's unnecessary handlers (when programmer's speciications are too many) nor suggest to programmers for specialized handlings (when programmer's speciica-tions are too general). We propose a static analysis of Java programs that estimates their exception ows independently of the programmer's speciications. This analysis is an extension of a class analysis to Java's exception mechanism. Its cost-eeectiveness balance is suggested by sparsely analyzing the program at method-level (hence reducing the number of unknowns in the ow equations).