Java Class Library Research Articles

RAGE: AJava-implemented Visual Random Generator

Carefully designed Java applications turn out to be efficient and platform independent tools that can compete well with classical implementations of statistical software. The project presented here is an example underlining this statement for random variate generation. An end-user application called RAGE (Random Variate Generator) is developed to generate random variates from probability distributions. A Java class library called JDiscreteLib has been designed and implemented for the simulation of random variables from the most usual discrete distributions inside RAGE. For each distribution, specific and general algorithms are available for this purpose. RAGE can also be used as an interactive simulation tool for data and data summary visualization.

BN++ – A Biological Information System

Summary Recent years have seen an explosive growth in the amount of biochemical data available. Numerous databases have been established and are being used as an essential resource by biologists around the world. The sheer amount and heterogeneity of these data poses a major challenge: data integration and, based thereupon, the integrative analysis of these data. We present BN++, the biochemical network library, a powerful software package for integrating, analyzing, and visualizing biochemical data in the context of networks. BN++ is based on a comprehensive and extensible object model (BioCore), which has been implemented as a C++ framework, a Java class library, and a relational database. The C++ framework is used to efficiently import, integrate, and analyze the data, which is stored in a data warehouse. The Java-based viewer (BiNA) provides a powerful platform-independent visualization of the data using sophisticated graph layout algorithms. Currently, the data warehouse imports and integrates data from about a dozen important databases including, among others, sequence data, metabolic and regulatory networks, and protein interaction data. We illustrate the usefulness of BN++ with a few select example applications.Availability: BN++ is open source software available from our website at www.bnplusplus.org.

Relational queries over program traces

Instrumenting programs with code to monitor runtime behavior is a common technique for profiling and debugging. In practice, instrumentation is either inserted manually by programmers, or automatically by specialized tools that monitor particular properties. We propose Program Trace Query Language (PTQL), a language based on relational queries over program traces, in which programmers can write expressive, declarative queries about program behavior. We also describe our compiler, Partiqle . Given a PTQL query and a Java program, Partiqle instruments the program to execute the query on-line. We apply several PTQL queries to a set of benchmark programs, including the Apache Tomcat Web server. Our queries reveal significant performance bugs in the jack SpecJVM98 benchmark, in Tomcat, and in the IBM Java class library, as well as some correct though uncomfortably subtle code in the Xerces XML parser. We present performance measurements demonstrating that our prototype system has usable performance.

DisASTer (distributed algorithms simulation terrain)

DisASTer (Distributed Algorithms Simulation Terrain) is a platform for the implementation of distributed algorithms. It provides a Java class library that eases the programming of distributed algorithms in Java. Moreover, DisASTer constitutes an execution environment that enables the user to specify interactively a topology at runtime. It allows the user to control the execution of the algorithm (start, stop, suspend, resume, go back and forth). In addition, the execution of a distributed algorithm can be observed through some built-in visualization panels (topology view, sequence view, message queue view). DisASTer supports the implementation of further application-specific views.

VYRD

We present a runtime technique for checking that a concurrently-accessed data structure implementation, such as a file system or the storage management module of a database, conforms to an executable specification that contains an atomic method per data structure operation. The specification can be provided separately or a non-concurrent, "atomized" interpretation of the implementation can serve as the specification. The technique consists of two phases. In the first phase, the implementation is instrumented in order to record information into a log during execution. In the second, a separate verification thread uses the logged information to drive an instance of the specification and to check whether the logged execution conforms to it. We paid special attention to the general applicability and scalability of the techniques and to minimizing their concurrency and performance impact. The result is a lightweight verification method that provides a significant improvement over testing for concurrent programs.We formalize conformance to a specification using the notion of refinement: Each trace of the implementation must be equivalent to some trace of the specification. Among the novel features of our work are two variations on the definition of refinement appropriate for runtime checking: I/O and "view" refinement. These definitions were motivated by our experience with two industrial-scale concurrent data structure implementations: the Boxwood project, a B-link tree data structure built on a novel storage infrastructure [10] and the Scan file system [9]. I/O and view refinement checking were implemented as a verification tool named VRYD (VerifYing concurrent programs by Runtime Refinement-violation Detection). VYRD was applied to the verification of Boxwood, Java class libraries, and, previously, to the Scan filesystem. It was able to detect previously unnoticed subtle concurrency bugs in Boxwood and the Scan file system, and the known bugs in the Java class libraries and manually constructed examples. Experimental results indicate that our techniques have modest computational cost.

A Flexible Java Class Library for Simulating and Teleoperating Robots

This paper presents a Java-3D-based software library for modelling industrial robot arms and programming simulation and tele-operation environments. Its main features are its portability, since it is developed with Java, its simplicity in defining different robots and including them in the final application, as well as its collision detection management. The library has been applied to the development of a simulation and tele-operation system, focused on the training of Robotics, which is also briefly described here.

Numerical problem solving for undergraduate core courses

Today, students often have computers in their dormitory rooms and backpacks that have the power of a typical 1970s university mainframe. It would be helpful if we could use computing power for explicit problem-solving and to develop students' intuition. In this article, the author explains a method that uses the Java programming language's built-in class structure to do this. The author also supplies a Java class library that can assist instructors in writing programs of this type.

Protocol animation based on event-driven visualization scenarios in real-time LOTOS

In this paper, we propose a method for animating behavior of communication protocols/systems based on event-driven visualization scenarios (VSs) described in a subclass of E-LOTOS called real-time LOTOS. In the proposed method, first we pick up some interesting events in the original specification of the protocol, and then describe a VS for those events so that the corresponding animations are executed just after their execution. We execute the original specification and its VS in parallel under a multi-way synchronization mechanism so that the corresponding animation is activated when each event in the original specification is executed. To describe animations in real-time LOTOS, we have defined some primitive animation operations as ADT functions. The pair of the original specification and its VS is converted into a multi-threaded Java program using our real-time LOTOS compiler where animation primitives described as ADT functions are replaced in the corresponding methods, implemented as Java class libraries. In our visualization method, we can specify the VS without modifying the original specification, and we can derive a Java program which animates the original specification in real-time. We have carried out an experiment to visualize a real-time LOTOS specification of a prioritized queuing mechanism of the differentiated service where two types of VSs for algorithm animation and performance evaluation are used for visualization.

A java toolkit for teaching distributed algorithms

We present a toolkit for developing and visualizing distributed algorithms in Java. This toolkit consists of a Java class library with a simple programming interface that allows to develop distributed algorithms in a message passing model. The resulting programs may be executed in standalone mode using a Java interpreter or embedded as applets into HTML documents and executed by a Web browser. The toolkit has been applied in various university courses and is freely available.

A development environment for predictive modelling in foods

Waikato Environment for Knowledge Analysis (WEKA) is a comprehensive suite of Java class libraries that implement many state-of-the-art machine learning/data mining algorithms. Non-programmers interact with the software via a user interface component called the Knowledge Explorer. Applications constructed from the WEKA class libraries can be run on any computer with a web-browsing capability, allowing users to apply machine learning techniques to their own data regardless of computer platform. This paper describes the user interface component of the WEKA system in reference to previous applications in the predictive modelling of foods.

Safe and Verifiable Design of Concurrent Java Programs

The design of concurrent programs has a reputation for being difficult, and thus potentially dangerous in safety-critical real-time and embedded systems. The recent appearance of Java, while cleaning up many insecure aspects of OO programming endemic in C++ , suffers from a deceptively simple threads model that is an insecure variant of ideas that are over 25 years old. Consequently, we cannot directly exploit a range of new CASE tools " based on modern developments in parallel computing theory " that can verify and check the design of concurrent systems for a variety of dangers such as deadlock and livelock that otherwise plague us during testing and maintenance and, more seriously, cause catastrophic failure in service. The approach proposed in this paper uses recently developed Java class libraries based on Hoare's Communicating Sequential Processes (CSP); the use of CSP greatly simplifies the design of concurrent systems and, in many cases, a parallel approach often significantly simplifies systems originally approached sequentially. New CSP CASE tools permit designs to be verified against formal specifications and checked for deadlock and livelock. We introduce CSP and its implementation in Java and develop a small concurrent application. The formal CSP description of the application is provided, as well as that of an equivalent sequential version. FDR is used to verify the correctness of both implementations, their equivalence, and their freedom from deadlock and livelock.

Simulating multiple inheritance in Java

Multiple inheritance is a feature whose worth has been vigorously debated, and even now there is no agreement as to whether a language should include it. Java does not have multiple inheritance, but its designers claim that many of the benefits of multiple inheritance can be gained through the use of a new feature, the interface. In this paper we explore the claims of the Java designers, and show how the interface may be used to simulate multiple inheritance. We first discuss the benefits of inheritance and multiple inheritance, and then demonstrate how the need for them arises in program development, using an extended example based on a real application. We then present the technique for simulating multiple inheritance, showing how it allows the main benefits of multiple inheritance to be achieved in Java. Finally, we discuss the limitations of the approach. In particular, we show how the approach faces difficulties when used with class libraries, such as the Java Core API, and we suggest a convention for Java class library designers that will mitigate this problem.

APIs for real-time distributed object programming

Ideally, according to the author, a real-time distributed programming method should be based on a general high-level style that could be easily accommodated by application programmers using C++ and Java. If such a method were to exist, these programmers could specify the interactions among distributed components and the timing requirements of various actions without expending much effort. Facilitating high-level, high precision, real-time object programming by establishing some form of language tools has consequently become a subject of great interest to the embedded systems community. This article focuses on application programming interfaces (APIs) that take the form of C++ and Java class libraries and support high-level, high precision, real-time object programming without requiring new language translators. These APIs wrap the services of the real-time object execution engines, which consist of hardware, node OSs, and middleware; they enable convenient high-level programming almost to the extent that a new real-time object language can. The author explains the API's fundamental features, how they interact among real-time objects, and how multicast channels and real-time multicast APIs contribute.

Java™ Class Libraries (2nd ed.,Vol. l, Supplement for the Java 2 Platform)

Java™ Class Libraries (2nd ed.,Vol. l, Supplement for the Java 2 Platform)

Translating a Linear Logic Programming Language into Java

There have been several proposals for logic programming language based on linear logic: Lolli [8], Lygon [7], LO [3], LinLog [2], Forum [11], HACL [10]. In these languages, it is possible to create and consume resources dynamically as logical formulas. The efficient handling of resource formulas is, therefore, an important issue in the implementation of these languages. Lolli, Lygon, and Forum are implemented as interpreter systems; Lolli is on SML and λProlog, Lygon is on Prolog, Forum is on SML, λProlog and Prolog. However, none of them have been implemented in Java.In this paper, we describe the Prolog Café 1 system which translates a linear logic programming language called LLP to Java via the LLPAM [12] [5], an extension of the standard WAM [16] [1] for LLP. LLP is a superset of Prolog and a subset of Lolli. The main difference from the first implementation [4] is resource compilation. That is to say, resource formulas are compiled into closures which consist of a reference of compiled code and a set of bindings for free variables. Calling these resources is integrated with the ordinary predicate invocation.Prolog Café is portable to any platform supporting Java and easily expandable with increasing Java's class libraries. In performance, on average, Prolog Café generate 2.2 times faster code for a set of classical Prolog benchmarks compared with jProlog.

The evolution of a high-performing Java virtual machine

Early JavaTM virtual machines (Jvms) possessed several significant performance bottlenecks that inhibited the speed of Java workloads. This paper presents the methodology that was used by IBM to identify and eliminate these bottlenecks for improving the performance of Java applications running on several operating system platforms. In addition, several of the key performance problems that were common to all early Java virtual machine implementations and how they were solved for IBM enhanced Jvms are described in detail. The issues discussed in this paper are focused on problems found in core Jvm components, such as object synchronization, object allocation, heap management, text rendering, run-time resolution, and Java class library methods. The results obtained from applying the described methodology and eliminating the identified performance bottlenecks increased the performance of IBM Java virtual machines by as much as four times on some workloads. The technology discussed in this paper is applicable to other Jvm implementations.

Java communication interfaces for control systems

We report an effort to lift the conceptual level of Java programming for communications in control systems to the level of CODARTS interfaces. Having implemented every component of the communication interfaces defined by CODARTS, we have constructed a Java class library that facilitates a direct mapping from CODARTS design diagram to Java program components. This will not only simplify the programming but also improve the quality of software.