Distributed component based systems seem to be the immediate future for software development. The use of such techniques, object oriented languages, and the combination with ever more powerful higher-level frameworks has led to the rapid creation and deployment of such systems to cater for the demand of internet and service driven business systems. This diversity of solution through both components utilised and the physical/virtual locations of those components can provide powerful resolutions to the new demand. The problem lies in the comprehension and maintenance of such systems because they then have inherent uncertainty. The components combined at any given time for a solution may differ, the messages generated, sent, and/or received may differ, and the physical/virtual locations cannot be guaranteed. Trying to account for this uncertainty and to build in into analysis and comprehension tools is important for both development and maintenance activities.

Issues involved in testing large distributed applications employing distributed object technologies are discussed. A testing tool, RiOT, that addresses these issues are described. RiOT can be used for testing distributed Java applications that use Java RMI, Jini, or Jiro technologies. It relies on the availability of the interface descriptions of the objects and services provided in the application. This information is used to define coverage domains that are used to assess the adequacy of tests. These interface-based coverage domains are based on 1) the methods and exceptions that are defined in the interfaces, 2) mutations that can be created from the methods and parameters, and 3) method sequences that can be defined from the methods. RiOT allows injection of faults at the interfaces of objects. Testers can observe the effects of fault injection and assess the fault handling capabilities of the application. RiOT can also be used to evaluate performance of the application using profiling information. RiOT employs a hierarchical monitoring framework for collecting test execution data. The components of RiOT communicate using Java RMI and rely on the use of the reflection mechanism for their functionality. RiOT's architecture is being extended with a distributed debugging and architecture visualization mechanism.

The permanently growing world-wide network infrastructure, allows more flexible distributed software development. Version and configuration management systems are the state of the art support for development teams. Distributed version and configuration management systems are usually employing the client/server scheme, where the client must be installed on the local machine under a specific operating system. This results in an update-problem of the only locally installed clients, when a new version of the client-software is required and has to be installed on all clients. The locally installed clients become even more problematic when extended functionality should be supported. To overcome this problem we have developed a scheme to provide a legacy version and configuration management system as Jini-services which are retrieved by an initial thin client.

This paper describes a client-server architecture for the creation of dynamic and self-adaptative instrumentation over the network, either local or the Internet. The proposed solution allows multiuser, multi-instruments sessions by the means of the cooperative aspects of Jini. Clients applications take advantage of this system-independent technology by using the Java programming langage.

In this paper we report on a study of the Jini technology for design of spontaneous networks offering services dynamically. We identify important design criteria such as flexibility, efficiency, dependability and transparency in the architectural design of spontaneous networks and illustrate how these criteria affect the specific design of a contact service offered within a Jini network. We explain the architectural design of the contact service, the lessons learned, and the future directions for research in extending the Quality of Service (QoS) and dependability enforcement in Jini networks. The report also includes a brief comparison with other current technologies for similar networks.

Jini is an infrastructure for spontaneous ad hoc service networks. It allows clients to find services without prior knowledge of their network surroundings. For service interaction proxy objects are used which are supplied by service providers. These proxy objects interact directly with the service provider. Compared to architectures that use a virtually central communications broker (like a CORBA ORB or an e-speak Core), this method offers a large amount of flexibility in the selection of an appropriate communication protocol. On the downside, debugging a distributed application using this approach is rather hard, as the interactions between clients and servers are not visible. This paper describes an approach using Java's dynamic proxies that allows component interaction in a Jini federation to be traced. By putting the functionality into the Jini lookup service, the approach is generic and transparent for both services and clients.

So that a military commander has precise command, control, and planning information available for a given mission, information must be tailored for a particular area of operation, for a specific level of command, and for a specific time period. The commander must be able to quickly understand the information, query related information, and analyze the information in collaboration with others to plan and control a military operation. To provide such tailored information, we envision an environment in which customized agents traverse a diverse, distributed, frequently changing information space to identify relevant data. Once aware of the data, visual interfaces facilitate understanding and navigation. Geographically separated users manipulate a customized view to access a common information framework in which they can interactively collaborate with other users. We propose an architecture for achieving this vision that is well suited to implementation with Jini networking technologies. As a first step toward achieving this architecture we have developed a collaborative visualization framework that enables multiple distributed users to interact using shared visual interface components while simultaneously communicating via a text-based chat window. Our framework provides communications management and messaging support and well-defined Java class interfaces for integrating visualization components. Initial results indicate significant benefits for application development through reuse and extensibility. We achieved interactive performance and synchronized collaboration using JavaSpaces as the underlying distributed technology.

This article describes the design and development of a virtual library, which pretends to give some contributions to the solution of some problems and issues pointed out in some research projects in this domain. The development of a SOAP/Z39.50 gateway is also described as an intermediary solution for the bibliographic information systems moving to simpler protocols in order to improve interoperability among them, using open technologies like Java and XML.

In the Mobile Agent programming model, small threads of execution migrate from machine to machine, performing their operations locally. For being able to deploy such a model into real world applications, security is a vital concern. In the M&M project we have developed a system that departures from the traditional platform-based execution model for mobile agents. In M&M there are no agent platforms. Instead there is a component framework that allows the applications to become able of sending and receiving agents by themselves in a straightforward manner. In this paper we examine the security mechanisms available in M&M, and how integration with existing applications is done. One difficult aspect of this work is that all the features must work with the security mechanisms that already exist on the applications. This is so because the components are integrated from within into the applications, which already have security mechanisms in place. Currently, M&M provides features like fine-grain security permissions, encryption of agents and data, certificate distribution using LDAP and cryptographic primitives for agents. For validating the approach and solutions found, we have integrated the framework into several off-the-shelf web servers, having the security mechanisms running, with no problems.

We describe the design and implementation of xdProf: a tool that captures and analyzes stack traces sent at a fixed interval from Java Virtual Machines in a distributed system. The xdProf client uses the Java Virtual Machine Profiling Interface and works with any compliant implementation; no access to application source code is necessary, no library modifications are needed, and there is no run-time instrumentation of Java byte code. Configuration options given at virtual machine startup specify the interval for stack trace transmission and the remote xdProf server. The xdProf server collects information from multiple xdProf clients and provides an extensible interface for analysis. Current tools include a graphical user interface for viewing the most recent stack traces from multiple virtual machines and the generation of control flow graphs for each virtual machine. The performance impact of the xdProf client sending data over a local area network is minimal: less than a 8% increase in total elapsed time for a set of standard benchmarks. Future plans include real-time visualization, reliability estimation, trace capture, and performance analysis.

Java software is often perceived to be slow as compared to corresponding C/C++ or FORTRAN software. For some computationally demanding algorithms, straightforward implementations in Java may run 100-150 times or more slower than C++ or FORTRAN. In the past, problem algorithms have included floating point intensive algorithms such as FFTs and integer functions such as endian and alignment byte manipulations. However, current JVMs do well with model floating point code such as FFTs and linear algebra. Java vectors and lists are somewhat slow compared to C++ equivalents; hashmaps can be very fast. Function calls in general, and getters and setters in particular, remain troublesome. Current JITs are extremely important for optimizing performance.

In distributed and in embedded systems, the size of the application is frequently a critical measurement. In many cases, a smaller size brings huge, tangible benefits and special formats, known as wire-formats, are specifically developed to minimize the footprint of applications. In a typical wire-format, very complicated transformations are applied to yield the smallest possible size, and the compressed application must undergo a time-consuming decoding phase before its execution. This article argues that decoding is a very important contributor to the overall performance of a wire-format and belongs to the evaluation of new formats. The article presents a model that considers both the transmission time and the decompression time to qualify wire-formats. It validates experimentally this model and compares with it two experimental wire-formats for compiled Java applications and the Java archive format.

JiroT Technology is an implementation of the Federated Management Architecture developed by Sun Microsystems Incorporated (SMI). It defines middleware to support the development of distributed system management applications. Since it has not yet gained the widespread popularity of other Java technologies there has been little published discussion of how architects and designers can take advantage of the specialized features it offers. In this paper, some of those key features are examined with respect to using the Unified Modeling Language (UML) during the development process.

Jini technology makes it possible to move parts of software from a device to another as a solution to achieve flexible distribution. Accordingly, each part of software that could be useful if available for other applications may also be made available for them. This interesting feature is particularly useful if there are lots of services and users for them. Even though Jini is easy to implement when building new software, it should be made very simple in order to be attached to existing solutions without large modifications. Especially if different parts of the existing software already have clear functional roles, for example as a client and as a server. In this paper, a framework encapsulating Jini functionality is presented. The purpose is especially to offer an easy add-on implementation for existing solutions. However, the framework has also been seen as useful when building simple Jini applications from scratch. The framework does not allow great flexibility but it offers simplicity. All that the Jini distribution requires is started by only a few commands in the code. The framework also takes care of the class transfer through a simple HTTP server without further user intervention. The framework is demonstrated with a video camera example. In the example, a moving picture of a video camera attached to a server may be followed in any node of the local area network with minimal software requirements. A multipurpose remote controller application is made to act as a universal client for all the programs that are built using the framework.

In a cluster environment the configuration and the upgrade of each part forming the cluster is a critical task. The growth of the cluster increases the difficulties and the number of components to manage. This paper proposes the Jini technology as a solution to make easier the management of the cluster. The present work faces with configuration and upgrade issues.

The Jini architecture presents a new opportunity for network designs: Network services are real objects, not remotely accessible objects. Sometimes we call this Objects in the network instead of objects on the network. This opens new questions in network service designs, such as how to design a service interface that allows the most network implementation strategies, or how one recovers from partial failures, or handles non-global time. This talk will deploy some questions of interest, discuss some answers or possible insights, and lay out some areas for future discussion and research. This paper presumes a basic knowledge of the Jini architects.