Tetsuo Tamai

How Does Requirements Quality Relate to Project Success or Failure

Our research goal is to Jind relations between requirements quality and project success. To attain the goal, we investigated 32 projects started and completed during the period of 2003-2005 in a large business application software development division of a company in Tokyo. Data of requirements specijication quality evaluated by software quality assurance teams as well as overall project pevormance data in terms of cost and time overrun were available. Requirements specijication quality data were Jirst converted into a multiple-dimensional space, each dimension corresponding to an item of the recommended structure of software requirements specijications (SRS) deJined in IEEE Std. 830-1998. We applied various statistical analysis techniques over the SRS quality data and project outcomes. Some interesting relations between requirements quality and project success or failure were found, including: 1) a relatively small set of SRS items have strong impact on project success or failure; 2) descriptions of SRS in normal projects tend to be balanced; 3) SRS descriptions in Section 1, where purpose, overview and general context of SRS are written, are rich in normal projects and poor in overrun projects; 4) when the descriptions of SRS Section 1 are poor while those of functions and product perspective are rich, the project tends to result in a cost overrun.

Aspect-oriented programming with model checking

Aspect-oriented programming (AOP) is a programming paradigm such that crosscutting concerns including synchronization policies, resource sharing and performance optimizations over objects are modularized as aspects that are separated from objects. A compiler, called a weaver, weaves aspects and objects together into a program. In AOP, however, it is not easy to verify the correctness of a woven program because crucial behaviors are strongly influenced by aspect descriptions. In order to deal with such problem, this paper proposes an automatic verification approach using model checking that verifies whether the woven program contains unexpected behaviors such as deadlocks. The objectives of this paper are as follows: 1) to verify the correctness of AOP-based programs using model checking, 2) to provide AOP-based model checking frameworks.

Software lifetime and its evolution process over generations

It is noted that the software evolution process does not end at the death of an individual software system but usually continues over generations through being replaced by newly built software. To explore this research topic, the authors conducted a survey, collecting data of software lifetimes, replacement practices, and factors of replacement. They report the results of the survey and discuss some possible long-range strategies for software life cycle planning and control based on the findings. The following issues related to such strategies are discussed; management by lifetime characteristics, monotonicity of size growth, and reuse.<<ETX>>

An adaptive object model with dynamic role binding

To achieve the goal of realizing object adaptation to environments, a new role-based model Epsilon and a language EpsilonJ is proposed. In Epsilon, an environment is defined as a field of collaboration between roles and an object adapts to the environment assuming one of the roles. Objects can freely enter or leave environments and belong to multiple environments at a time so that dynamic adaptation or evolution of objects is realized. Environments and roles are the first class constructs at runtime as well as at model description time so that separation of concerns is not only materialized as a static structure but also observed as behaviors. Environments encapsulating collaboration are independent reuse components to be deployed separately from objects. In this paper, the Epsilon model and the language are explained with some examples. The effectiveness of the model is illustrated by a case study on the problem of integrated systems. Implementation of the language is also reported.

Framework for matching requirements elicitation techniques to project characteristics

One of the most difficult jobs for requirements engineers is to select an appropriate RE method for the project at hand. Good engineers make good choices and have skills in applying selected techniques appropriately. Poor engineers usually have a narrow choice range limited by their training and biased by their experience. Once a RE technique that does not fit the current project is selected, the project is doomed to fail. In this article, we propose a framework to characterize typical RE techniques and use it as a base for selecting appropriate techniques at the time a project is started, as well as at the time a change in the nature of the project is recognized, or an obstacle is encountered in defining a suitable set of requirements. Copyright

RoleEP: role based evolutionary programming for cooperative mobile agent applications

Using mobile agent systems, cooperative distributed applications that run over the Internet can be constructed flexibly. However, there are some problems: it is difficult to understand collaborations among the agents as a whole, and it is difficult to define the behaviors of agents because they are dynamically influenced by their external context. So, in general, constructions of cooperative distributed applications based on mobile agent systems are considered as very hard and difficult works. In this paper, the concept of RoleEP (Role-based Evolutionary Programming) is proposed in order to alleviate these problems. RoleEP provides a systematic evolutionary programming style. In RoleEP, a field where a group of agents collaborate with each other is regarded as an environment, and a function that an agent assumes in an environment is defined as a role. Descriptions only concerning the collaborations among agents can be abstracted by environments. An object becomes an agent by binding itself with a role that is defined in an environment, and it then acquires the functions needed for collaborating with other agents that exist in the same environment. Distributed applications based on mobile agent systems, which may change their functions dynamically in order to adapt themselves to their external context, can be constructed by synthesizing environments dynamically.

Understanding the process of participating in open source communities

The number of participants in Open Source Software (OSS) communities has increased. Not only volunteers participate, but also companies and their employees. The motivation of the participants vary from extrinsic to intrinsic values. Community-managed and sponsored OSS projects try to explore these motivations to attract and keep these participants. This paper analyses three different OSS projects: MySQL, OpenOffice.org, and GNOME. Each has a different organizational structure that influences participants behavior. This study analyzes qualitative data from publicly available documents, such as projects wiki pages and projects webpages, and quantitative data from bug tracking systems and source code repositories. One of our findings is that the number of active developers does not change significantly when the total number of committers increases for the selected OSS projects.

Separation of Concerns in Mobile Agent Applications

Using mobile agent systems, cooperative distributed applications that run over the Internet can be constructed flexibly. However, there are some problems: it is difficult to understand collaborations among agents and travels of individual agents as a whole because mobility/collaboration functions tend to be intertwined in the code; it is difficult to define behaviors of agents explicitly because they are influenced by their external context dynamically. Many aspects of mobility/ collaboration strategies including traveling, coordination constraints, synchronization constraints and security-checking strategies should be considered when mobile agent applications are constructed.In this paper, the concept of RoleEP (Role Based Evolutionary Programming) is proposed in order to alleviate these problems. In RoleEP, a field where a group of agents roam around hosts and collaborate with each other is regarded as an environment and mobility/collaboration functions that an agent should assume in an environment are defined as roles. An object becomes an agent by binding itself to a role that is defined in an environment, and acquires mobility/collaboration functions dynamically. RoleEP provides a mechanism for separating concerns about mobility/collaboration into environments and a systematic evolutionary programming style. Distributed applications based on mobile agent systems, which may change their functions dynamically in order to adapt themselves to their external context, can be constructed by synthesizing environments dynamically.

Objects and roles: Modeling based on the dualistic view

Abstract There are many situations where modeling based on the dual concepts of objects and roles has an advantage over modeling based solely on objects. In this paper, we survey works related to this dualistic model view and clarify the characteristics of such models. Then, we introduce our research on developing a computational model and a language based on this objective dualism.

Objects as Actors Assuming Roles in the Environment

To achieve the goal of realizing object adaptation to environments, a new role-based model Epsilonand a language EpsilonJare proposed. In Epsilon, an environment is defined as a field of collaboration between roles and an object adapts to the environment assuming one of the roles. Objects can freely enter or leave environments and belong to multiple environments at a time so that dynamic adaptation or evolution of objects is realized. Environments and roles are the first class constructs at runtime as well as at model description time so that separation of concerns is not only materialized as a static structure but also observable as behaviors. Environments encapsulating collaboration are independent reuse components to be deployed separately from objects. In this paper, the Epsilon model and the language are explained with some examples. The effectiveness of the model is illustrated by a case study on the problem of integrated systems. Implementation of the language is also reported.