UML 1.3 has made a pair of changes concerning the use-case relationships; one is to move include and extend that used to be stereotypes of the generalization into those of the dependency, and the other is to introduce a true generalization. A use-case generalization, however, is practically useless and therefore the changes are rather worsening the situation. The ACU or Actors-Call-Use-cases conjecture, which is actually against the definition of a use case, is found buried in OOSE (Object-Oriented Software Engineering). It distorts the features of use-case objects and is the root cause of the problems. Strictly following the definition of a use case, a real-world model is built that represents a typical situation of using a use case in the analysis and design stages, and a use case is reified as an ordinary object. The use-case specification thus constructed successfully solves the problems.

There is a great deal of literature claiming that the capture-and-recapture (CR) method can estimate the number of remaining software bugs during the test process, and this enables us to decide when to stop testing. Although the decision about when to stop testing can only be made when there is ample confidence that the number of remaining bugs is less than a certain limit, most of the literature just makes a point estimate of it, using a simple proportional formula, without considering the level of errors. Some of the literature touches on the fact that the recaptured bug number is given by a hypergeometric distribution, but none uses the confidence interval estimate effectively. This paper derives a formula giving a confidence interval estimate for the seeded bug ratio. Then it presents a virtual experiment to apply the CR method. The paper concludes that the CR method cannot be effectively applied to software testing because it overestimates the number of bugs to be detected before testing can be stopped, and the CR method is not applicable at all to the final phase of testing because it is very difficult to make enough seeded bugs that are equivalent to those remaining in the target software.

This paper describes a four-year experimental sof'ware reuse project conducted at Software Laboratories, Nippon Telegraph and Telephone.The targets of reuse are program code modules stored in a common library.The project is first described in detail; its framework, organizational structure, and activities are presented.The statistical results of the project are then shown.Some important aspects of software reuse are discussed, including impediments to software reuse, incentives and domain selection.Finally, it concludes that sof!ware reuse is inherently a managerial issue and that key factors for successful software reuse are senior management comtritment and good domain selection.

An experimental software reuse project was performed over a period of four years. The target of reuse was program code modules stored in a common library. The author first outlines the project, presents and analyzes the results, and then discusses the managerial and technological issues of software reuse.>

A bug-locating assistant system, CHASE, is described. It facilitates program debugging by automatically chasing the program part that caused an error found during execution and by displaying the program state for investigation. The current version is a prototype that records execution history for all variables. The next version of CHASE will implement controlled recording, whereby variables recorded and sampling points will both be controlled.>

A description is given of VIPS, a visual debugging system which makes it easy to debug programs by visually displaying the program execution from various aspects using multiple windows. VIPS automatically acquires data type information from the program to be debugged and rapidly displays data structures. The current version of VIPS aims at list structures, which are the most difficult type of data structures for debugging. A preliminary evaluation shows that VIPS enables a user to find bugs in about 30% less time using about 25% fewer debugging commands compared with a conventional debugging tool.>

This paper describes a global compaction algorithm which can produce efficient microprograms with respect to both space and time. The algorithm depends upon a generalized data dependency graph (GDDG), which can integratedly express the concurrency of microorders and their mobility past the boundaries of basic blocks, as well as the control flow for a microprogram. In the algorithm an initial GDDG is first built up from a source microprogram consisting of a sequence of microorders, and this is transformed by repeated application of a set of microscopic transformation rules to the graph's edges until all of them have been examined. Then microorders are packed into microinstruction fields so that the more frequently executed basic blocks may contain as few microinstructions as possible. The intrinsic nature of the control flow's joins and forks allows determination of which basic block should accommodate those microorders that can be placed in more than one basic block.