This paper proposes subject-object modeling as a new design approach for reactive software. Subject-object modeling combines the strength of the existing object and process paradigms of computation. Each paradigms stress the close relationship between the structure of the software and the structure of the problem. The object paradigm sees the world in terms of objects sending messages to each other, while the process paradigm sees it in terms of communicating sequential processes. With both paradigms, the structure of the software can be directly patterned on the structure of the problem environment, providing a seamless transition from analysis to design. The problem with the object paradigm is that it does not handle timing well. Some object-oriented authors play down the timing aspect and regard the operations on objects as "shopping lists" to be picked from in any order. But timing is essential in many systems and particularly in reactive software. The process paradigm captures time dependencies, but forces the user to regard even trivial objects in process terms, which is often cumbersome and counter-intuitive. Subject-object modeling enhances the object paradigm with a means to express time relationships beyond the scope of any one object and enhances the process paradigm with object decomposition as a means for information hiding and for the handling of simple objects. The analyst's goal is a compelling description of the problem domain based on processes operating on objects, where the processes capture the timing and ordering of operations on objects. Such a problem description is useful in its own right. It can also be mapped directly onto a software design. In an Ada environment, processes map onto tasks and the objects become packages (or instances of abstract data types.) In this paper, the subject-object approach is applied to a problem with free-floating buoys and an elevator control problem. The solution to the buoy problem is compared to an earlier-published object-based solution.
As the power of information technology grows and its cost diminishes, training is shifting into complex, computer-maintained worlds. The primary reason for this transition is effectiveness; richly detailed virtual environments leverage the most important variables for educational success. These types of training applications can enhance learners' motivation to spend time on task, provide collaborative experiences to foster peer teaching, tailor material to each student's needs and background, and promote the transferability of complicated knowledge and skills into real-world settings. This report describes progress in three aspects of virtual environments that draw on ideas from artificial intelligence: artificial realities, virtual communities, and knowbots.
Mutation is a software testing technique that requires the tester to generate test data that will find specific, well-defined errors. Mutation testing executes many slightly differing versions, called mutants, of the same program to evaluate the quality of the data used to test the program. Although these mutants are generated and executed efficiently by automated methods, many of the mutants are functionally equivalent to the original program and are not useful for testing. Recognizing and eliminating equivalent mutants has traditionally been done by hand, a time-consuming and arduous task, which limits the practical usefulness of mutation testing. This paper presents extensions to previous work in detecting equivalent mutants; specifically, we present algorithms for determining several classes of equivalent mutants, and results from an implementation of these algorithms. These algorithms are based on data flow analysis and six compiler optimization techniques. We describe each of these techniques and how they are used to detect equivalent mutants. The design of the tool, and some experimental results using it are also presented. Finally, a new approach for detecting equivalent mutants that may be more powerful than the optimization techniques is introduced.