This paper reports on an evaluation result of current obfuscation techniques for Java byte code, such as Collberg's techniques in terms of mutational capability, real-time applicability, and program size increase. We suggest effective obfuscation techniques for random and real-time obfuscation (RR obfuscation). In the evaluation results, the combination of some obfuscation techniques was found to be useful for RR obfuscation, and some obfuscation techniques makes little or no difference after a certain threshold.

We present an approach and a web-based system implementation for modeling shapes using real distance functions. The system consists of an applet supporting the HyperFun modeling language. The applet is extended with primitives defined by Euclidean distance from a point to the surface of the shape. Set-theoretic operations (union, intersection, difference) that provide an approximation of the Euclidean distance to a shape built in a constructive way are introduced. Such operations have a controllable error of the exact Euclidean distance to the shape and preserve C1 continuity of the overall function, which is an important condition for further operations and applications. The proposed system should help model various shapes, store them in a concise form, and exchange them easily between different entities on a network. The applet offers also the possibility to export the models defined in the HyperFun language to other formats for raytracing or rapid prototyping.

Although production systems are widely used in artificial intelligence (AI) applications, they are seen to have certain disadvantages in terms of their need for special purpose assistance software to build and execute their knowledge-bases (KB), and in the fact that they will not run on any operating system (platform dependency). Furthermore, for AI applications such as learning assistance systems, there is a strong requirement for a self-adaptive function enabling a flexible change in the service contents provided, according to the user. Against such a background, a Java based production system (JPS) featuring no requirement for special purpose assistance software and no platform dependency, is proposed. Furthermore, a new self-adaptive Java production system (A-JPS) is proposed to realize the "user adaptation" requirement mentioned above. Its key characteristic is the combination of JPS with a Causal-network (CN) for obtaining a "user profile". In addition, the execution time of the JPS was studied using several benchmark problems with the aim of comparing the effectiveness of different matching algorithms in their recognize-act cycles as well as comparing their performance to that of traditional procedural programs for different problem types. Moreover, the effectiveness of the user adaptation function of the A-JPS was studied for the case of a CN with a general DAG structure, using the experimental KB of a learning assistance system.

The sizes of recent Java-based server-side applications, like J2EE containers, have been increasing continuously. Past techniques for improving the performance of Java applications have targeted relatively small applications. Moreover, when the methods of these small target applications are invoked, they are not usually distributed over the entire memory space. As a result, these techniques cannot be applied efficiently to improve the performance of current large applications. We propose a dynamic code repositioning approach to improve the hit rates of instruction caches and translation look-aside buffers. Profiles of method invocations are collected when the application performs with its heaviest processor load, and the code is repositioned based on these profiles. We also discuss a method-splitting technique to significantly reduce the sizes of methods. Our evaluation of a prototype implementing these techniques indicated 5% improvement in the throughput of the application.

In this paper we present a component approach for configurable network processing for active documents. The approach has two key ideas. The first is to enable documents to process themselves on networks. That is, documents can define their own itineraries, like the notion of active packets in active network technology. The second is to enable documents to transmit other documents to their destinations as first-class objects, such as the notion of active nodes in active netwwork technology. The approach also enables buidling and managing active documents as compound documents. The dynamic deployment of network processing for exchanging documents can be defined and achieved by means of GUI-based manipulation of compound documents. Therefore, the approach allows a user to easily and rapidly develop and customize network processing in the same way as if that user had edited the documents. A prototype implementation of the approach and its applications were constructed on a Java-based mobile agent system to evaluate the effectiveness of the approach.

The market for IP convergence services is expanding rapidly due to the rising number of Internet users. To respond to market trends, service systems must provide services quickly. This paper discusses that application server called the service agent which provides IP convergence services. The service agent meets the requirements for four application servers, centralized intelligence, supporting various interfaces: service creativity and scalability. The architecture is based on that of AIN systems, but whole system is written in Java especially to achieve service creativity and scalability. As a result of trial manufacture, feasibility of the service agent and scalability was achieved. Enough performance was also confirmed to obtain for commercial services.

For network computing on desktop machines, fast execution of Java bytecode programs is essential because these machines are expected to run substantial application programs written in Java. We believe higher Java performance can be achieved by exploiting instruction-level parallelism (ILP) in the context of Java JIT compilation. This paper introduces VLaTTe, a Java JIT compiler for VLIW machines that performs efficient scheduling while doing fast register allocation. It is an extended version of our previous JIT compiler for RISC machines called LaTTe whose translation overhead is low (i.e., consistently taking one or two seconds for SPECJVM98 benchmarks) due to its fast register allocation. VLaTTe adds the scheduling capability onto the same framework of register allocation, with a constraint for precise in-order exception handling which guarantees the same Java exception behavior with the original bytecode program. Our experimental results on the SPECJVM98 benchmarks show that VLaTTe achieves a geometric mean of useful IPC 1.7 (2-ALU), 2.1 (4-ALU), and 2.3 (8-ALU), while the scheduling/allocation overhead is 3.6 times longer than LaTTe's on average, which appears to be reasonable.

We propose a method for analyzing trade-off between an environment where a Java mobile code application is running and requirements for the application. In particular, we focus on the security-related problems that originate in low-level security policy of the code-centric style of the access control in Java runtime. As the result of this method, we get feasible requirements with respect to security issues of mobile codes. This method will help requirements analysts to compromise the differences between customers' goals and realizable solutions. Customers will agree to the results of the analysis by this method because they can clearly trace the reasons why some goals are achieved but others are not. We can clarify which functions can be performed under the environment systematically. We also clarify which functions in mobile codes are needed so as to meet the goals of users by goal oriented requirements analysis(GORA). By comparing functions derived from the environment and functions from the goals, we can find conflicts between the environments and the goals, and also find vagueness of the requirements. By resolving the conflicts and by clarifying the vagueness, we can develop bases for the requirements specification.

In this paper, we present a flexible distributed computing system in which it is very easy to add required computing components at any time. The system is an Internet-based solution, and mainly developed by Java and XML. Moreover, by implementing a new configuration of computing information that is setting up Public Information and Private Information, the system can accommodate various computing requests, and facilitate a flexible design. Additionally, to show the practical merit, as an example of signal processing, we presented how to apply our proposed system to selection of a suitable artificial neural network.

A Java execution environment is implemented, in which a hardware engine is operated in parallel with an embedded processor. This pair of hardware facilities together with an additional software kernel are devised for existing embedded systems, so as to execute Java applications more efficiently in such a way that 39 instructions are added to the original Java Virtual Machine to implement the software kernel. The exploration of design parameters is also attempted to attain a low hardware cost and high performance. The proposed hardware engine of a 6-stage pipeline can be integrated in a single chip using 30 k gates together with the instruction and data cache memories. The proposed approach improves the execution speed by a factor of 5 in comparison with the J2ME software implementation.

This paper presents a framework for building mobile agent-based components. The framework introduces the notion of agent hierarchy and inter-agent migration and thus allows a group of mobile agents to be dynamically assembled into a single mobile agent. It provides a powerful method of constructing complex, large-scale mobile agent-based applications. To demonstrate how to exploit our framework, we construct an extensible and portable mobile agent system for executing and migrating hierarchical mobile agents. The system itself is also implemented as a collection of mobile agents and can thus dynamically change and adapt its functions through migrating agents that offer the functions. Mobile agent-based applications running on the system can naturally inherit the extensibility and adaptability of the system.

Making up an electromagnetic wave simulator based on the FEM is tried, which may run on some widely used platforms by use of Java and a single commercial tool. Since the codes and configuration files to be created for this simulator are common, one can construct the simulator running on the platforms at the same time. Using this simulator, the transmission properties of two- and three-dimensional waveguide discontinuities in optical and microwave waveguides are analyzed, the inverse problem in material constant measurement is solved, and the computed results are presented including plots of the electric field distribution.

We can easily access a remote database as well as a local database with HTML forms. Although implementing a database application with HTML forms is much simpler than implementing it with a proprietary graphical user-interface system, HTML forms and CGI programs still must be coded. We implemented a software tool that automatically generates the SQL statements that create a database for an application, the forms that are used as a user interface, and the Java servlets that retrieve the data requested through the forms. The database tables to be created and the forms to be generated are determined by the class diagram for the application. Our software tool, which we call WebSiteGen, thus simplifies the implementation of a Web-based database application.

We present a design framework of a high-end server based on Single-Flux-Quantum (SFQ) circuit technologies. The server proposed here has multiple microprocessors and memories, which are mounted on a single board or package and are connected each other by SFQ interconnection switches. The extremely large bandwidth up to 100 Gbps/channel in the interconnection will be realized because of high throughput nature of the SFQ circuits. SFQ memories or Josephson-CMOS hybrid memories are employed as the shared memory of the multiprocessor. The SFQ microprocessors are constructed based on the complexity-reduced (CORE) architecture, in which complexity of the system is eased in exchange for using a high clock rate of the SFQ circuits. The processor is so-called Java-processor that directly executes the Java Byte Codes. Assuming a proper advancement of the Nb/AlOx/Nb integrated circuit process technology, we have estimated that the power consumption of the server system including a cryocooler is reduced by a factor of twenty as compared to the future CMOS system with the same processor performance, while the SFQ system has 100 times of magnitude larger memory-processor bandwidth.

In the field of mobile information devices for personal use, JavaTM has been a focus of attention. It provides easy development of network-oriented applications and is equipped with a mechanism for adding or deleting a application service dynamically. This is implementing wide-ranging, personal preference-oriented services, such as games or electronic commerce requiring high security capability. It also as a programming language is an object-oriented language which is greatly effective in improvement of software productivity. While having such advantages, Java is bottlenecked in a low running speed in such an embedded environment with strict resource restrictions as mobile information devices. This low running speed limits applications to be used, thus killing its potential. This time, we have built the Java runtime environment for embedded equipment which is executed at a high speed by hardware, in order to improve the running speed up to 20 times as fast as conventional software implementation.

This paper describes the JAINTM JavaTM Call Control (JCC) Application Programming Interface (API), and its relationship to network protocols, in particular the Session Initiation Protocol (SIP). JCC is a high-level object-oriented open, standard API for Next Generation Network (NGN) softswitches that enables rapid creation, by third parties, of services that can run independently of the underlying network technology (e.g. wireless, wired, packet, IP, PSTN) and protocols. SIP is a protocol that has been proposed for a wide variety of uses in IP networks, including call control. We argue that instead of being competitors, JCC and SIP are complementary, with JCC offering higher-layer programming abstractions and protocol-independence, and demonstrate by examples how to map JCC version 1.0 to a SIP environment. We thus show that for common call control applications using JCC is simpler, faster and less maintenance intensive than using SIP directly.

Most distributed systems are based on either the C/S (Client/Server) model or the P-to-P (Peer to Peer) model. In C/S based distributed systems, a client invokes a server and waits for the server reply. Because of this sequential nature, C/S based distributed systems can be implemented by the RPC (Remote Procedure Call) scheme. Most tools for developing distributed objects are based on the RPC scheme. Whereas, in P-to-P based distributed systems, each distributed objects work concurrently, by exchanging asynchronous messages, without waiting for the receiver's action. To implement these P-to-P distributed systems, the RPC scheme is not powerful enough, and the active object model using asynchronous messages is suitable. This paper explains the pure Java library CAPE for developing P-to-P based distributed active object systems.

We have developed an active Q adaptor (AQA) to achieve integration of multiple management protocols and dynamic modification of managed object (MO) definitions. To achieve dynamic modification, we introduce a new MO framework, called dynamic-MO, which has the ability of modifying its own definition. A dynamic-MO is composed of meta-data and some behavior programs. Meta-data lists attributes of a dynamic-MO in a text format and a behavior program describes actions of a dynamic-MO in scripting language such as Java, Tcl, etc. In our AQA architecture, modules which manage individual components of a dynamic-MO communicate among themselves via an object request broker (ORB) in order to achieve system scalability with high performance. To realize the functionality of a dynamic-MO, we propose interfaces among these modules that are independent of dynamic-MO definitions and an update mechanism of behavior programs. We define the interfaces based on the common management information protocol (CMIP) operations to avoid re-defining the interfaces when dynamic-MO definitions are modified. Furthermore, to execute modified behavior programs without any negative influence on the workings of the other behavior programs, we employ a Java class-loader which has its own specific naming-space on a Java virtual machine (Java VM). With all of these features, our AQA is extremely promising for developing programmable network management systems for end-to-end management of heterogeneous telecommunication networks.

Today's complicated and heterogeneous telecommunication network environments need fully-integrated, cost-effective, user-friendly management systems. When developing such management systems in distributed environments, many telecommunication companies are carefully adopting CORBA and Java technologies. CORBA technology enables developers to create and manipulate distributed management system components easily while Java technology liberates human users from complicated and proprietary management system interfaces. In this paper, we propose a TMN-based integration framework for distributed network management by combining both CORBA and Java technologies. The framework generalizes a logically-layered architecture from the management agents layer to the user interface layer. It also provides generalized TMN management interfaces using inter-domain gateway systems for coordinating heterogeneous management protocols. By using these interfaces, TMN management function components can be easily constructed as CORBA objects to provide powerful TMN management services to administrators via user-friendly Web browsers. On the basis of this framework, we have designed and implemented a TMN alarm surveillance system which realizes our framework.

In this paper, we design and implement a Web-based Internet/Intranet service management system which can support Quality of Service (QoS) contracted by users and service providers, using Service Level Agreement (SLA) concept. We have analyzed the requirements and management information for Internet/Intranet service management. Based on this analysis, we have defined the suitable QoS parameters for the management of Internet/Intranet services, and developed new WWW service Management Information Bases (MIBs) for QoS management by extending the existing IETF's MIBs. The support of QoS management is done by incorporating the SLA concept, which is measured, monitored and controlled systematically in a multi-domain environment. Finally, we have built a prototype system, and evaluated its performance. The prototype system utilizes Java and CORBA technologies, so that various benefits of these technologies such as platform independence and scalability can be obtained.