The productivity of developing software for switching systems and the effects of using advanced software development methods were evaluated and analyzed. Productivity was found to be improved by using automatic code generation, simulator debugging, a hierarchical object-oriented software structure, and software-development-support tools. The evaluation showed that the total productivity was improved by about 20%, compared with a case where these efforts were not introduced. It also showed each effect of these methods and tools by evaluating their manpower saving ratios. These results are expected to benefit the development of various types of communication-switching and multimedia service systems. Also, our development-support tools and methods are expected to be the basis for attaining higher software development productivity.

The software requirements specification process consists of three steps; requirements capture and analysis, requirements definition and specification, and requirements validation. At the beginning of the second step which this paper focuses on, there have been several types of massive documents generated in the first step. Since the developers and the clients/users of the new software system may not have common knowledge in the field which the system deals with, it is difficult for the developers to produce correct requirements specification by using these documents. There has been few research work to solve this problem. The authors have developed a support tool to produce correct requirements specification by arranging and restructuring those documents into clearly understandable forms. In the second step, the developers must specify the functions and their constraints of the new system from those documents. Analyzing the developers' real activities for designing the support tool, the authors propose a model of this step as the following four activities. To specify the functions of the new system, the developers must collect the sentences which may suggest the functions scattering those documents. To define the details of each function, the developers must gather the paragraphs including the descriptions of the functions. To verify the correctness of each function, the developers must survey all related documents. To perform above activities successfully, the developers must manage various versions of those documents correctly. According to these four types of activities, the authors propose the effective ways to support the developers by arranging those documents. This paper shows algorithms based on this model by using the structures of the documents and keywords which may suggest the functions or constraints. To examine the feasibility of their proposal, the authors implemented a prototype tool. Their tool extracts complete information scattering those documents. The effectiveness of their proposal is demonstrated by their experiments.

A Multi-Agent Learning Language (MALL) is defined as being necessary for agents in environments where they encounter crucial situations in which they have to learn about the environment, other parties moves and strategies, and then construct an optimal plan. The language is based on two major factors, the level of certainty in fully monitoring (surveying) the agents and the environment, and optimal plan construction, in an autonomous way. Most of the work related to software agents is based on the assumption that other agents are trustworthy. In the growing Internet environment this may not be true. The proposed new learning language allows agents to learn about the environment and the strategies of their opponents while devising their own plans. The language is being tested in our project of software agents for Electronic Commerce that operates in various security zones. The language is flexible and adaptable to a variety of agents applications.

This paper reports on an Intelligent CASE tool, applicable in a structured programming phase, or from detailed design to coding. This is automation of the bottom level in the hierarchical design process of detailed design and coding, where the largest man-hours are consumed. The main idea is that human designers use a CASE tool for the initial design of a software system, and the design knowledge is automatically acquired from the structured charts and stored in the knowledge base. The acquired design knowledge may be reused in designs. By reusing it, a similar software system may be designed automatically. It has been shown that knowledge acquired in this way has a Logarithmic Learning Effect. Based on this, a quantitative evaluation of productivity is made. By accumulating design experiences (e. g. 10 times), more than 80% of the detailing designs are performed automatically, and productivity increases by up to 4 times. This tool features universality, an essentially zero start-up cost for automatic design, and a substantial increase in software productivity after enough experiences have been accumulated. This paper proposes a new basic idea and its implementation, a quantitative evaluation applying techniques from Industrial Engineering, which proves the effectiveness of the proposed system.

Development of large-scale software is usually conducted through a project to unite a work force. In addition, no matter what kind of life cycle model is employed, a development plan is required for a software development project in order for the united work force to function effectively. For the project to be successful, it is also necessary to set management objectives based on this plan and confirm that they are achieved. This method is considered to be effective, but actually making a software development project and following the achievement of the management objectives at each step is not easy because predicting the necessary work amount and risks that the project involves is difficult in software development. Therefore, it is necessary to develop a system to support software project management so that the project manager can manage the entire project and the work load is reduced. This paper proposes a meta-model of work structure of software development projects for project management by using an object-oriented database with constraints as well as a framework for software project management systems based on this meta-model. Also proven, through an example of a system that analyzes repercussions on progress of a software development project, is that the meta-model and framework are effective in software project management.

In order to build up a process-centered software engineering environment using ontologies, we present a methodology to manually construct the following ontologies: an object ontology constructed based on constituent elements to make up objects (products), and a process ontology constructed based on the relationships between inputs and outputs. Afterwards, using the constructed ontologies, the environment generates software process plans good for user queries, with both user interaction and constraints satisfaction by the Generate and Test paradigm. Furthermore, case studies show us that the environment works well in generating software process plans good for a query about the intermediate stage of development, between basic design and detailed design.

Workers involved in software projects are unlike those working on a production line in a manufacturing field usually engaged in plural work (that is, not only main development work but also various other work), concurrently. Such other work might put pressure on the schedule of the whole project. Therefore, to manage the whole project, not only main development work but also various other work should be dealt with as management objects and workers' workload should be taken into consideration (that is, who is doing what work at what workload at what time). This paper proposes a framework for workload management facilities for managing software projects. This framework proposes to relate not only main development work but also various other work and each work step within cooperative work to the workers. This paper also shows the behavior of the facilities by using an example and shows its usefulness based on the application of a prototype system. Using this system, users can assign work to workers by simulating workers' workload. These facilities help managers grasp workers' workload as well as help workers grasp their assigned work.

The datapath width of a core processor has a strong effect on cost, power consumption, and performance of an embedded system integrated with memories into a single-chip. However, it is difficult for designers to appropriately determine the datapath width for each application because of the limited reusability of software and the lack of compilation techniques. The purpose of this paper is to clarify supports required from software for the optimal datapath width determination. As a solution, an embedded programming language, called Valen-C, and a retargetable Valen-C compiler are proposed. In this paper, the syntax and semantics of Valen-C along with the mechanism of the Valen-C retargetable compiler and how to preserve the accuracy of computation of programs in relation to various datapath widths are also described. Experiments with practical applications show that the total cost of the system including a core processor, ROM, and RAM is drastically reduced with little performance loss by reducing the datapath width.

Hardware software codesign using various hardware and software implementation possibilities requires a cosimulation environment which has both flexibility and efficiency. In this paper, a hardware software cosimulation environment is developed using the backplane approach and optimized synchronization. To seamlessly integrate a new simulator, this paper defines and implements the backplane protocol for communication and synchronization between client simulators. Automatic interface generation facility is also devised for more effective cosimulation environment. To enhance the performance of cosimulation backplane, a series of optimized hardware software synchronization methods are introduced. Efforts are focused on reducing control packets between simulators as well as concurrent execution of simulators without roll-back. The environment is implemented based on Ptolemy and validated with a QAM example run on different configurations. With optimized synchronization method, we have achieved about 7 times speed-up compared with the lock-step synchronization.

A major topic in the field of network and telecommunications is doing business on the World Wide Web (WWW), which is called Electronic Commerce (EC). Another major topic is blending Artificial Intelligence (AL) techniques with the WWW. In the Ex-W-Pert Project we have proposed an agent model for EC components that blends the traditional expert systems' reasoning engine with a multi-layer knowledge base, communication and documentation engines. In this project, EC is viewed as a society of software agents, such as customer, search, catalog, manufacturer, dealer, delivery and banker agents, interacting and negotiating with each other. Each agent has a knowledge-base and a reasoning engine, a communication engine and a documentation engine. The knowledge-base is organized in three layers: skill layer, rule layer and knowledge layer (S-R-K layers). In this project, for each EC agent, we identify the class of problems to be solved and build the knowledge base gradually for each layer. We believe that using this multi-layer knowledge base system will speed up the reasoning and ultimately reduce the operation costs.

This paper describes key techniques for automatic program generation of office data handling for all types of switching systems. Our office data scenario tool generates logical-physical office data conversion programs to be installed in switching systems. Also, it generates logical office data generation programs to be installed in a logical office data generation tool that converts office conditions to a logical office data file. We were able to apply this tool to all the office data types for our new switching systems, and automatically generated about 5. 5% of the total program size. This technique reduces not only the software production cost but also the bug ratio because there is no room for human error. Also, switching system programs are much more portable, since no machine-code-dependent parts are involved in office data handling. Thus, we expect that these techniques will be the basis for highly productive, reliable, and portable software platforms for the next-generation multimedia communication systems.

Exception handling is not only useful for increasing program readability, but also provides an effective means to check and locate errors, so it increases productivity in large-scale program development. Some typical and frequent program errors, such as out-of-range indexing, null dereferencing, and narrowing violations, cause exceptions that are otherwise unlikely to be caught. Moreover, the absence of a catcher for exceptions thrown by API procedures also causes uncaught exceptions. This paper discusses how the exception handling mechanism should be supported by the compiler together with the operating system and debugging facilities. This mechanism is implemented in the compiler by inserting inline check code and accompanying propagation code. One drawback to this approach is the runtime overhead imposed by the inline check code, which should therefore be optimized. However, there has been little discussion of appropriate optimization techniques and efficiency in the literature. Therefore, a new solution is proposed that formulates the optimization problem as a common assertion elimination (CAE). Assertions consist of check code and useful branch conditions. The latter are effective to remove redundant check code. The redundancy can be checked and removed precisely with a forward iterative data flow analysis. Even in performance-sensitive applications such as telecommunications software, figures obtained by a CHILL optimizing compiler indicate that CAE optimizes the code well enough to be competitive with check suppressed code.

Evaluating analytically computer architecture performance is mostly cheap and quick. However, existing analytical performance evaluation techniques usually have a difficult and time-consuming modeling process. Moreover, existing techniques do not support well the capability for finding the bottleneck and its cause of a target system being evaluated. To address the above problems and to enhance analytical performance evaluation technology, in this paper we propose a software tool that accepts system models described in a specification language, generating an executable program that performs the actual performance evaluation. The whole approach is built on a subsystem-oriented performance evaluation tool, which is, in turn, based on a formal subsystem-oriented performance evaluation technique and a subsystem specification language.

For usage in fading environments, the idea of utilizing radio signal processing with software programmable devices promises greater flexibility and functionality. However, to realize these benefits very high performance DPSs and AD converters are required, especially for adaptive antennas with CDMA. One potential method of reducing the implementation complexity is to employ multicarrier (MC) modulation as it allows parallel signal processing in addition to its benefits in combating fading and ISI effects. This paper proposes a system utilizing MC DS/CDMA and a recursive adaptive array antenna processing algorithm for estimating the array response vector (array manifold) and hence the optimal weights. In order to evaluate this system performance results obtained through computer simulations are presented. The proposed MC system improves the accuracy of the direction-of-arrival (DOA) estimation of the signal by 2 degrees as compared with a single carrier system. It is also shown that the proposed adaptive array antenna algorithm for MC DS/CDMA reduces the number of iterations of the power method significantly and allows parallel processing of the adaptive algorithm.

As open-ended distributed systems and mobile computing systems have spread widely, the need for software which can adapt itself to the dynamic change of runtime environments increases. We call the ability of the software dynamic adaptability. We designed and implemented a language LEAD that provides an architecture for dynamic adaptability. The basic idea is to introduce the mechanism which changes procedure invocation dynamically according to the states of runtime environments. Using LEAD, we can easily realize 1) the highly extensible dynamically adaptable applications, and 2) the introduction of the dynamic adaptability into existing applications.

This paper proposes polling-based real-time software for MPEG2 System protocol LSIs, which is a typical embedded and real-time system on a chip, and demonstrates its performance and usefulness. The polling-based real-time software is designed and optimized by analyzing application specific function requirements and deciding scheduling intervals and the execution cycles of each task. It requires neither hardware for multiple interrupt handling nor software for heavy context switching. The polling-based approach provides sufficient performance without any hardware and software overhead for a real-time application like the MPEG2 System protocol.

In this paper, we consider a simple development process consisting of design and debug phases, which is derived from actual concurrent development process for embedded software at a certain company. Then we propose two-phase project control that examines the initial development plan at the end of design phase, updates it to the current status of the development process and executes the debug phase under the new plan. In order to show the usefulness, we define three imaginary projects based on actually executed projects in a certain company: the project that executes debug phase under initial plan, the project that applies the proposed approach, and the project that follows a uniform plan. Moreover, to execute these projects, we use the project simulator, which has already been developed based on GSPN model. Judging from the number of residual faults in all products, we found that project B is the best among them.

Key technologies are presented for enhancing the reusability of software in communication switching node systems along with the results obtained from porting software between several types of node systems, including N-ISDN, B-ISDNs, and Intelligent Networks. A reusable software platform based on object-oriented designing and programming techniques has been established and mechanisms for reusing object classes has been developed. Analysis of the reusability showed that this platform can be applied to various types of communication systems and that an average of more than three quarters of a system's programs can be ported. By using our software reuse framework to develop software components, we were able to reduce the time needed to develop device management programs by about 30%. Furthermore, about 80% of these programs can be ported to other systems, so introducing this platform improves software programming productivity.

Based on a recent remarkable development of digital beamforming (DBF) antenna technologies, we propose a new concept of kaleidoscopic antenna, we call it "software antenna," which is a more general one extending DBF schemes. The software antenna instantly reconfigures itself adapting its software and hardware to changes in the radio-environment. To realize the software antenna, the development of high-speed reconfigurable FPGAs is indispensable. As an intelligent antenna, we believe the software antenna could play a key role in the days of software radio having a function of mobile computing.

We present a comparison of correlated failures for multiversion software using community error recovery (CER) and software breeding (SB). In CER, errors are detected and recovered at checkpoints which are inserted in all the versions of the software. SB is analogous to the breeding of plants and animals. In SB, versions consist of loadable modules, and a driver exchanges the modules between versions to detect and eliminate faulty modules. We formulate reliability models to estimate the probability of failure for software using either CER or SB. Our reliability models assume failures in the checkpoints in CER and the driver in SB. We use beta-binomial distribution for modeling correlated failures of versions, because much of the evidence suggests that the assumption that failures in versions occur independently is not always true. Our comparison indicates that multiversion software using SB is more reliable than that using CER when the probability of failure in the checkpoints in CER or the driver in SB is 10-7.