Software development project managers have already known that adding manpower to a late software project makes it later. This is a famous sentence in "Mythical man-month" written by Brooks (1975). The managers also recognize that even if two man-month workloads are assigned to two developers, the development period is not one month. However, the managers want to see when the two developers finish the two man-months workload. Of course, the managers don't think that the development period reduces from two months to one month. If the development period in the two developers is shorter than two months, the managers will decide to add the new developer to the work. Therefore, we propose a new workload estimation model based on communications among shared works. The model includes the Concept Model of UML of a software development project. The classes and relationships in the Concept Model present the kinds of works and relationships among the works, respectively. Sharing works causes increments of communication workload. The communication workload is derived from the relationships among the classes in the Concept Model. In case studies using the model, we were able to reconfirm quantitatively the famous sentence of "Mythical man-month".

When implementing an application system in a distributed computing environment, several architectural questions arise, such as how and where computing resources are arranged, and how the communication among computing resources are implemented. To simplify the process of making these choices, we have developed an architectural style for distributed processing system. The style classifies product lines for distributed processing systems into nine categories based on the location of data storage and the style of processing between client and server. This paper describes our architectural style and proposes a simple but practical method to select an appropriate architectural style for developing an application system. We apply this selection method in concrete real application systems.

This paper proposes an efficient technique for eye gaze interface suitable for the general GUI environments such as Microsoft Windows. Our technique uses an eye and a hand together: the eye for moving cursors onto the GUI button (move operation), and the hand for pushing the GUI button (push operation). We also propose the following two techniques to assist the move operation: (1) Automatic adjustment and (2) Manual adjustment. In the automatic adjustment, the cursor automatically moves to the closest GUI button when we push a mouse button. In the manual adjustment, we can move the cursor roughly by an eye, then move it a little more by the mouse onto the GUI button. In the experiment to evaluate our method, GUI button selection by manual adjustment showed better performance than the selection by a mouse even in the situation that has many small GUI buttons placed very closely each other on the GUI.

Java programs distributed through the Internet are now suffering from program theft. This is because Java programs can be easily decomposed into reusable class files and even decompiled into source code by program users. We propose a practical method that discourages program theft by embedding Java programs with a digital watermark. Embedding a program developer's copyright notation as a watermark in Java class files will ensure the legal ownership of class files. Our embedding method is indiscernible by program users, yet enables us to identify an illegal program that contains stolen class files. The result of the experiment to evaluate our method showed most of the watermarks (20 out of 23) embedded in class files survived two kinds of attacks that attempt to erase watermarks: an obfuscactor attack, and a decompile-recompile attack.

Presents an experiment in understanding how learners of the Java programming language comprehend its concepts, such as classes, inheritance, interfaces, etc., in lectures and exercises. The authors used an empirical technique to test conjectures about how we learn the programming language. Usually, observations about how we learn a programming language are treated anecdotally. In this experiment, learners received lectures and did an exercise. The comprehension states of the learners were measured by tests in three learning phases. The first phase was before the lecture. In this phase, the learners had no knowledge of the programming language. The second phase was after the lecture and before the exercise. Here, the learners acquired some basic knowledge. The third phase was after the exercise. In this phase, the learners put the acquired knowledge into practice. Factor analysis was used to obtain factors affecting the test result of each learning phase. Changes in comprehension states are explained as a result of tracing the factors between the learning phases.

One of the major problems in object-oriented software projects is the lack of management's ability to comprehend and control the development progress of a project. This is because traditional phases of software development are not appropriate for object-oriented development. The project manager's "road map" is likely to be different with different phases, different milestones, and different checkpoints. This paper proposes a new framework which gives us a guideline for generating software process with relevant milestones for object-oriented development methods. The framework provides algorithms for identifying development phases and baseline products based on relationships among activities and products of the development method. In addition, the framework defines a software process model to manage a development progress in which milestones are established at the end of each phase in order to check the baseline product and establish goals for the following phase. Results of the application of the proposed framework show that the framework can generate a software process customized for well-known object-oriented development methods in a systematic way.

Empirical software engineering can be viewed as a series of actions to obtain knowledge and a better understanding about some aspects of software development, given a set of problem statements in the form of issues, questions or hypotheses. Experience has made us aware of the criticality of integrating the various types of data that are collected and analyzed as well as the criticality of integrating the various types of activities that take place, such as experiment design and the experiment itself. This has led us to develop a Computer-Aided Empirical Software Engineering (CAESE) framework to support the empirical software engineering lifecycle. The paper first presents the CAESE framework that consists of three elements: (1) a process model for the "lifecycle" of empirical software engineering studies, including needs analysis, experiment design, actual experimentation, and analyzing and packaging results; (2) a model that helps empirical software engineers decide how to look at the "world" to be studied in a coherent manner; (3) an architecture, based on which CAESE environments can be built, consisting of tool sets for each phase of the process model, a process management mechanism, and the two types of integration mechanism that are vital for handling multiple types of data: data integration and control integration. Next, the paper describes the Ginger2 environment as an instantiation of our framework. It concludes with reports on case studies using Ginger2, which dealt with a variety of empirical data types including mouse and keystrokes, eye traces, 3D movement, skin resistance level, and videotaped data.

Although object oriented languages can help make software more reusable, class libraries can be difficult to use unless the programmer knows the library well. In particular, it can be hard to find and understand components that a programmer may want to reuse. The article focuses on novice programmers solving programming tasks which require the reuse of components. We take an in-depth look at how the programmers find the necessary components, and identify strategies that they use to achieve it. We also comment on the type of tool that is necessary from the viewpoint of the strategies.

We describe an experiment investigating the distribution of failure intensity in software reliability growth models.We found that the assumption of conventional models that the failure intensity follows a gamma distribution is not always true.Our new software reliability model does not make this assumption; rather, the failure intensity is calculated from failure data.We show that our new model predicts more accurately the number of detected faults for our study project than the conventional models.

While small computer systems have provided us with a wide array of development and operational environments, implementation methods, and domains of the software to be developed, it has also made the software development more risky. This paper proposes a new framework for improving the software development process on small computer systems to reduce software development risks. The key idea of the proposed framework is that the solutions to the software development problems can be extracted by the project manager, with relatively low overload, from the development processes that were actually executed in order to reduce the development risks, and then be formalized and stored in a database. The formalized solutions can be used not only for process improvement, but also for devising new solutions if new problems should occur in the future. We believe that the proposed framework is capable of making up for the difficulties in implementing CMM on small computer systems, and it encourages us to apply CMM to such risky software development.

One of the major problems in object-oriented software projects is the lack of management ability to comprehend and control the development progress of a project. This is because traditional phases of software development are not appropriate for object-oriented development. The project manager's "road map" is likely to be different with different phases, different milestones, and different checkpoints. The paper proposes a new framework which gives one a rigorous guideline for generating software process with relevant milestones for various kinds of software development methods, especially for object-oriented development methods. The framework provides algorithms for identifying development phases and baseline products based on relationships among activities and products of the development method. In addition, the framework defines a software process model to manage a development progress in which milestones are established at the end of each phase in order to check the baseline product and establish goals for the following phase. Results of the application of the proposed framework show that the framework can generate a software process customized for well-known object-oriented development methods in a systematic way.

In many cases of small scale software development, downstream activities are actually carried out before upstream activities have completely finished in order to reduce the development time and meet the deadline. However, overlapping activities also increase the total work effort because it demands more communications between activities. It is very important to be able to estimate the tradeoff between development time and total work effort since constraints may be placed on them. The paper proposes a simulation model to describe the overlapping development processes and the effects between overlapped activities. Based on this model, a software process simulator was developed. This simulator is applicable for supporting project planning (scheduling and staffing) with constraints on cycle time and total work effort.

The paper proposes a new method for increasing the reliability of multiversion software systems. The software using software breeding is more reliable than one using N version programming. But software breeding is not suitable for real time application because program versions are executed several times for detecting faulty modules. In the proposed method, the detection of faulty modules is performed in the background when program versions fail and the software continues the execution in the foreground. When the detection of faulty modules is finished, the combination of module versions in program versions are changed. Ten simulations, each of which executed program versions 10/sup 6/ times, were performed to analyse the effectiveness of the new method. This resulted in the reduction of the number of failures to range from 33% to 76% with an average of 56%.

I discuss several results of analysis related to software engineering. I show a result of analyzing research topics discussed in the software engineering community in the last two decades. I introduce an analytical result on important issues in the future and discuss the software gap between Japan and US.>

This paper compares Software Breeding, a new approach for improving the reliability of multiversion software, with Community Error Recovery by mathematical models of the reliability of the multiversion software by these. The following results were obtained: (1) the reliability of the Software Breeding increases when the number of modules of the multiversion software increases, (2) the multiversion software by Software Breeding is more reliable than by the Community Error Recovery unless the reliability of a program version is low and (3) the Software Breeding can improve the reliability of multiversion software more easily than the Community Error Recovery since the Software Breeding does not need any additional routine which must have very high reliability except for the driver module.

Recently, software development is following hardware development in terms of features such as downsizing and short time-to-market. In the past, software development took place slowly in a centralized computer environment. On the other hand, recent software has the potential to be released in a rather short development time, because of the availability of distributed development environments and workstations. In this kind of short lifecycle, software reliability should be a central quality concern but not be overwhelmed. The trade-off among different factors of qualities becomes even more important than in the traditional big size development style. We have to evaluate the acquired quality in quantitative way, and in order to do this we need a suitable measure. To have such a measure, we need to have appropriate data we can analyze. As a result, we must have precise data.

A method is described for constructing software development support system from the description of software product relations. Logical structures of the products have ben expressed by a tree structure. Each product appearing through the software development corresponds to a leaf in a tree and a set of those products and other sets correspond to an internal node. Various kinds of software development are easily expressed by changing the products at the leaves. The description of product relation is translated into a script of process description language (PDL). A support system is obtained by executing the translated PDL script with the PDL interpreter which the authors have developed.>

A new metric for evaluating the cost effectiveness of technical reviews is described. The proposed metric is based on the degree to which testing costs are reduced by technical reviews. The metric can be interpreted as combining two conventional metrics. Using an experimental evaluation of the conventional metrics and the proposed metric for data collected in an industrial environment, the authors show the validity and usefulness of the proposed metric. In particular, they present a method to estimate a value of the proposed metric by using only the values obtained at review phase.>

Requirement to describing software development processes in formal manners has been increased, and demand for altering and tailoring the process descriptions has been emerged.In this paper, we propose a functional language PDL (Process Description Language), designed to describe various development processes under a certain environment.To create and modify the PDL scripts easily and correctly, we propose a method of stepwise refinement from abstract scripts into concrete scripts.By this method, the abstract definitions of software process flow and product flow initially given as function definitions in PDL, are transformed into the concrete definitions of the tool activations, message displays, and so on.We also discuss an architecture design of a software development environment (Adaptable Software Development Environment), which can be adapted in many ways for designer's requirements.

A syntax-analysis Mgorithm is presented for a language generated by an unambiguous context-free grammar in a number of elementary operations proportional to n = log n, where n is the length of a given string, using a random access memory.The amount of memory required for the algorithm is proportional to n 2 log n.The proposed algorithm is a modified version of Cocke's algorithm and utilizes a eertair, property of unambiguous normal grammars.