To represent interactive objects, we propose a choice-disjunctive declaration statement of the form $S add R$ where S, R are the (procedure or field) declaration statements within a class. This statement has the following semantics: request the user to choose one between S and R when an object of this class is created. This statement is useful for representing interactive objects that require interaction with the user.

Object-oriented languages have recently become common, making register indirect jumps more important than ever. In object-oriented languages, virtual functions are heavily used because they improve programming productivity greatly. Virtual function calls usually consist of register indirect jumps, and consequently, programs written in object-oriented languages contain many register indirect jumps. The prediction of the targets of register indirect jumps is more difficult than the prediction of the direction of conditional branches. Many predictors have been proposed for register indirect jumps, but they cannot predict the jump targets with high accuracy or require very complex hardware. We propose a method that resolves jump targets by forwarding execution results. Our proposal dynamically finds the producers of register indirect jumps in virtual function calls. After the execution of the producers, the execution results are forwarded to the processor's front-end. The jump targets can be resolved by the forwarded execution results without requiring prediction. Our proposal improves the performance of programs that include unpredictable register indirect jumps, because it does not rely on prediction but instead uses actual execution results. Our evaluation shows that the IPC improvement using our proposal is as high as 5.4% on average and 9.8% at maximum.

Petri nets are known as a modeling language for concurrent and distributed systems. In recent years, various object-oriented Petri nets were proposed, and we are proposing a kind of object-oriented Petri nets, called multi agent nets (MANs). In this letter, we consider the reachability analysis of MANs. We propose an algorithm for generating an abstract state space of a multi agent net, and report results of computational experiments.

In the age of pervasive computing, ubiquitous collaboration has become an every-day life paradigm. Without an ideal computing infrastructure, issues with ubiquitous collaboration, such as network unreliability, platform heterogeneity, and client's resource constraints, are inevitable. The traditional replication scheme copes with network unreliability by replicating all the objects of a shared application together at once. This is, however, suitable for neither cooperative applications nor mobile computing devices. These problems can be naturally addressed by using a fine-grained replication scheme that enables a portion of the application objects to be replicated. This paper presents an object-oriented middleware that is capable of dynamically and transparently replicating remotely shared Java applications in a partially and on-demand incremental manner. It is also able to maintain various consistency semantics and enables the coexistence of fine-grained replications and conventional remote method invocations. Empirical results indicate several practical benefits of the middleware.

Inference attacks mean that a user derives information on the execution results of unauthorized queries from the execution results of authorized queries. Most of the studies on inference attacks so far have focused on only inference of positive information (i.e., what value is the execution result of a given unauthorized query). However, negative information (i.e., what value is never the execution result of a given unauthorized query) is also sensitive in many cases. This paper presents the following results on the security against inference attacks on negative information in object-oriented databases. First, inference of negative information is formalized under a model of object-oriented databases called method schemas. Then, the following two types of security problems are defined: (1) Is a given database instance secure against inference attacks on given negative information? (2) Are all of the database instances of a given database schema secure against inference attacks on given negative information? It is shown that the first problem is decidable in polynomial time in the description size of the database instance while the second one is undecidable. A decidable sufficient condition for any database instance of a given database schema to be secure is also proposed. Finally, it is shown that for a monadic schema (i.e., every method has exactly one parameter), this sufficient condition is also a necessary one.

This paper proposes a model for access control within object-oriented systems. The model is based on RBAC (role-based access control) and is called DRBAC (dynamic RBAC). Although RBAC is powerful in access control, the original design of RBAC required that user-role assignments and role-permission assignments should be handled statically (i.e., the assignments should be handled by human beings). Nevertheless, the following dynamic features are necessary in access control within a software system: (a) managing dynamic role switching, (b) avoiding Trojan horses, (c) managing role associations, and (d) handling dynamic role creation and deletion. DRBAC offers the dynamic features. This paper proposes DRBAC.

The increasing complexity and shorter life cycle of software have made it necessary to reuse software. Object-oriented development has not facilitated extensive reuse of software and it has become difficult to manage and understand modern object-oriented systems which have become very extensive and complex. However, components, compared with objects, provide more advanced means of structuring, describing and developing systems, because they are more coarse grained and have more domain-specific aspects than objects. In addition, they are also suited to a current distributed environment due to their reusability, maintainability and granularity. In this paper, we present a process of extracting components from object-oriented systems. We define some static metrics and guidelines that can be applied to transform object-oriented systems into component-based systems. Our process consists of two parts. First, basic components are created based on composition and inheritance relationships between classes. Second, the intermediate system is refined into a component-based system with our proposed static metrics and guidelines.

Refactoring is one of the promising techniques for improving software design by means of behavior-preserving structural transformation, and is widely taken into practice. In particular, it is frequently applied to design models represented with UML such as class diagrams. However, since UML design models includes multiple diagrams which are closely related from various views, to get behavior-preserving property, we should get the other types of design information and should handle with the propagation of the change on a diagram to the other diagrams. For example, to refactor a class diagram, we need behavioral information of methods included in the class and should also refactor diagrams which represent the behavior, such as state diagrams, activity diagrams. In this paper, we introduce refactoring on design models as transformations of a graph described by UML class diagram and action semantics. First, we define basic transformations of design models that preserve the behavior of designed software, and compose them into refactoring operations. We use Object Constraint Language (OCL) to specify when we can apply a refactoring operation. Furthermore we implement our technique on a graph transformation system AGG to support the automation of refactoring, together with evaluation mechanism of OCL expressions. Some illustrations are presented to show its effectiveness. The work is the first step to handle with refactoring on UML design models in integrated way.

Cohesion is an important software attribute, and it is one of significant criteria for assessing object-oriented software quality. Although several metrics for measuring cohesion have been proposed, there is an aspect which has not been supported by those existing metrics, that is "cohesive-part size." This paper proposes a new metric focusing on "cohesive-part size," and evaluates it in both of qualitative and quantitative ways, with a mathematical framework and an experiment measuring some Java classes, respectively. Through those evaluations, the proposed metric is showed to be a reasonable metric, and not redundant one. It can collaborate with other existing metrics in measuring class cohesion, and will contribute to more accurate measurement.

Detecting the possibility of inference attacks is necessary in order to keep a database secure. Inference attacks mean that a user tries to infer the result of an unauthorized queries to the user. For method schemas, which are a formal model of object-oriented databases, it is known that the security problem against inference attacks is decidable in polynomial time in the size of a given database instance. However, when the database instance or authorization has slightly been updated, it is not desirable to check the entire database again for efficiency. In this paper, we propose several sufficient conditions for update operations to preserve the security. Furthermore, we show that some of the proposed sufficient conditions can be decided much more efficiently than the entire security check. Thus, the sufficient conditions are useful for incremental security checking.

Web Services (WS) have received significant attention recently. Delivering Quality of Service (QoS) on the Internet is a critical and significant challenge for WS community. This article proposes a Web Services Testing Framework (WSTF) for WS participates to perform WS testing. WSTF provides three main distributed components: test master, test agents and test monitor. Test master manages scenarios and generates test scripts. It initiates WS testing by sending test scripts to test agents. Test agents dynamically bind and invoke the WS. Test monitors capture synchronous/asynchronous messages sent and received, attach timestamp, and trace state change information. The benefit to use WSTF is that the user only needs to specify system scenarios based on the system requirements without needing to write test code. To validate the proposed approach, this paper used the framework to test a supply-chain system implemented using WS.

Software with design flaws increases maintenance costs, decreases component reuse, and reduces software life. Even well-designed software tends to deteriorate with time as it undergoes maintenance. Work on restructuring object-oriented designs involves estimating the quality of the designs using metrics, and automating transformations that preserve the behavior of the designs. However, these factors have been treated almost independently of each other. A long-term goal is to define transformations preserving the behavior of object-oriented designs, and automate the transformations using metrics. In this paper, we describe a genetic algorithm based restructuring approach using metrics to automatically modify object-oriented designs. Cohesion and coupling metrics based on abstract models are defined to quantify designs and provide criteria for comparing alternative designs. The abstract models include a call-use graph and a class-association graph that represent methods, attributes, classes, and their relationships. The metrics include cohesion, inheritance coupling, and interaction coupling based on the behavioral similarity between methods extracted from the models. We define restructuring operations, and show that the operations preserve the behavior of object-oriented designs. We also devise a fitness function using cohesion and coupling metrics, and automatically restructure object-oriented designs by applying a genetic algorithm using the fitness function.

This paper describes glyph representation, that is, shape representation of inheritance relationships between a superclass and subclasses in an object-oriented programming language. The inheritance relationships in object-oriented programming languages are usually represented in a visual programming environment by a diagram of a tree graph or a nested structure. That diagram is not integrated with a code view showing control and data flows. Using the proposed representation, one can understand the inheritance relationships of classes and the assignment compatibility or type conformance just by seeing the glyphs. One thus does not need to look at a hierarchy diagram in order to recognize them. The inheritance relationships are represented by inclusion relationships of glyphs. Methods for generating suitable glyphs from a class hierarchy are also described, as is a prototype system for glyph generation. Experiments using the Java 2 Standard Edition (J2SE), which has more than 1,500 classes, show that one can recognize inheritance relationships in the proposed representation faster than in the usual textual representation. Consequently the proposed representation can facilitate the understanding of inheritance in visual object-oriented programming environments.

In this paper we discuss the estimation of effort needed to update program codes according to given design specification changes. In the Object-Oriented incremental development (OOID), the requirement changes occur frequently and regularly. When a requirement change occurs, a design specification is changed accordingly. Then a program code is updated for given design specification change. In order to construct the development plan dynamically, a simple and fast estimation method of efforts for code updating is strongly required by both developers and managers. However, existing estimation methods cannot be applied to the OOID. We therefore try to propose a straightforward approach to estimate effort for code updating, which reflects the specific properties of the OOID. We list up following factors of the effort estimation for OOID: (1) updating activities consist of creation, deletion, and modification, (2) the target to be updated has four kinds of types (void type, basic type, library type, and custom type), (3) the degree of information hiding is classified into private, protected and public, and (4) the degree of inheritance affects updating efforts. We then propose a new formula E(P,σ) to calculate the efforts needed to update a program P according to a set of design specification changes σ. The formula E(P,σ) includes weighting parameters: Wupd, Wtype, Winf-h and Winht according to the characteristics (1), (2), (3) and (4), respectively. Finally, we conduct experimental evaluations by applying the formula E(P,σ) to actual project data in a certain company. The evaluation results statistically showed the validity of the proposed approach to some extent.

We propose the architecture of efficiently and flexibly extensible solver system for electromagnetic wave simulations, that can load multi kinds of schemes such as Finite-Difference Time-Domain (FDTD) scheme, Finite Element Method (FEM), and a circuit simulator, with various boundary conditions in the system. Object-oriented approach is a promising method for efficient development of the flexible simulator. The primary object in the architecture is found through our object-oriented analysis as decomposed "region" from whole the simulation space. The decomposed region is considered to be the stage on which the electromagnetic fields play under the local rules. Developers who will extend the functionality of the system can add new classes inherited from the abstract classes in our design depending on the grid structure, the scheme, or the boundary processing method.

A knowledge gap between network operators and system developers in Network Management System (NMS) construction has widened. This has been caused by an expansion of supported business processes and increasingly sophisticated network management functions. This gap makes system development costly and time consuming. Function development, led by operators, is a promising solution to the problems caused by the gap. This type of development should not require an operator to know how to develop NMS. Standard objects may be used to meet this requirement and save time and the cost of NMS construction. However, they are not sufficient to design functions supporting some tasks that are for providing custom services. In this paper, we propose a partial extension package, composed of several object classes. This package is attached to the standard objects to design a custom function. Information processing in a new function can be added, and easily modified, using this package. This package specifies states that invoke the information processing. It also includes objects that add new data without changing standard objects. It makes use of several design patterns in order to weaken coupling to the standard objects. We have applied this package to two programs. One plans maintenance tasks schedules, the other sets threshold values for quality of service. We made use of software metrics to measure their performance in terms of flexibility. The results show that the proposed package continues to make it possible to reuse the standard objects, and makes it easy to modify the behavior of a new function.

Method invocation mechanism is one of the essential features in object-oriented programming languages. This mechanism contributes to data encapsulation and code reuse, but there is a risk of runtime type errors. In the case of object-oriented databases (OODBs), a runtime error causes rollback. Therefore, it is desirable to ensure that a given OODB schema is consistent, i.e., no runtime error occurs during the execution of queries under any database instance of the OODB schema. This paper discusses the computational complexity of the type-consistency problem. As a model of OODB schemas, we adopt update schemas introduced by Hull et al., which have all of the basic features of OODBs such as class hierarchy, inheritance, complex objects, and so on. The type-consistency problem for update schemas is known to be undecidable. We introduce a subclass of update schemas, called acyclic schemas, and show that the type-consistency problem for acyclic schemas is in coNEXPTIME. Furthermore, we show that the problem for recursion-free acyclic schemas is coNEXPTIME-hard and the problem for retrieval acyclic schemas is PSPACE-complete.

The hardware-software codesign of distributed embedded systems is a more challenging task, because each phase of codesign, such as copartitioning, cosynthesis, cosimulation, and coverification must consider the physical restrictions imposed by the distributed characteristics of such systems. Distributed systems often contain several similar parts for which design reuse techniques can be applied. Object-oriented (OO) codesign approach, which allows physical restriction and object design reuse, is adopted in our newly proposed Distributed Embedded System Codesign (DESC) methodology. DESC methodology uses three types of models: Object Modeling Technique (OMT) models for system description and input, Linear Hybrid Automata (LHA) models for internal modeling and verification, and SES/workbench simulation models for performance evaluation. A two-level partitioning algorithm is proposed specifically for distributed systems. Software is synthesized by task scheduling and hardware is synthesized by system-level and object-oriented techniques. Design alternatives for synthesized hardware-software systems are then checked for design feasibility through rapid prototyping using hardware-software emulators. Through a case study on a Vehicle Parking Management System (VPMS), we depict each design phase of the DESC methodology to show benefits of OO codesign and the necessity of a two-level partitioning algorithm.

This letter empirically evaluates the way how to calculate the complexity of methods, that is used in the definition of WMC(Weighted Method per Class), one of the Chidamber and Kemerer's metrics. With respect to the results of our experiment, Halstead's Software Science metric is the most appropriate one to evaluate the complexity of the methods.

For plasma simulations, we developed a one-dimensional (1d) Object-Oriented Particle-in-Cell code for X11-based Unix workstations (XOOPIC) by modifying the current two-dimensional version which was originally developed by PTSG (Plasma theory and simulation group) in the University of California at Berkeley. We implemented a simplified field solve and current deposition in the code. We retained three components of particle velocity, although the spatial variation for particle position and field components is limited to one dimension. To verify the function of the 1d code, we perform simulations with typical models such as the Child-Langmuir current model and electromagnetic wave propagation in plasma. In both cases, the simulation results quantitatively agree with the theory.