an object-oriented, knowledge-based approach to simulation  simulation is an integral part of the industry's analysis tools. industry's demands for simulation are growing and simulations are becoming larger as well as more complex. simulation plays such a key role because it can:  offer early insight into the behavior of planned systems  support the evaluation of alternate system architectures, algorithms, etc  provide an inexpensive training vehicle  however, the "conventional" (i.e. procedural, code-like) approach to building simulations has three undesirable traits. first, the conventional approach can be unresponsive to user needs because the intended user has little opportunity to provide meaningful guidance during the development process. the user may have one notion of how the simulation should behave and the developer perhaps another. the divergence in their ideas may not become apparent until late in the development process, after much time and money has been spent. one way to improve this situation is to rapidly prototype the simulation and allow the developer and user to mold the simulation into a final product reflecting the intended user's desires. second, conventional simulations can be difficult to modify because the assumptions and knowledge about the simulated objects are dispersed implicitly throughout the simulation's code. thus, modifying a simulation requires the implementor to know exactly what code segments to change and where to find them. we can improve this situation by explicitly representing both the model's assumptions and knowledge about the simulated objects. thirdly, simulations notoriously provide copious output which requires highly trained analysts to interpret properly. this output is used both for debugging as well as analysis. interpreting the simulation output can be time-consuming because the analyst must know what information is needed and where to find it. we can remedy this if the human interface to the simulation results is almost "intuitive" and graphical.  the preliminary results of an irad project at general research corporation suggest that object-oriented programming coupled with interactive graphics and knowledge-based techniques form the basis for a greatly improved simulation methodology for a broad class of simulation problems. in this paradigm, the simulated entities are represented as "objects" whose behavior is controlled by rules and who communicate with other objects and the user by "message passing". the objects themselves are represented by icons which can be interactively inspected and modified.  this type of modularity promotes rapid prototyping and incremental development object-oriented programming paradigms do not force the designer/developer to design or develop in a strictly top-down or bottom- up fashion. the developer may focus on the objects and their behavior at any level of detail. the simulation can quickly reflect changing and increasing knowledge of the simulated domain without necessarily modifying the entire system and the associated debugging which accompanies system modifications. the developer modifies the object's behavior by modifying the rules which govern that object. other objects need not necessarily interact differently with the modified object. the messages which pass among objects are generic and do not usually require the type of implementation-dependent detail needed in other styles of programming.  simulations constructed in this way often have browser and explanation facilities so a user may directly inspect the behavior of a simulated entity and request an explanation of the behavior. this capability also decreases the need for massive amounts of simulation-generated data for analysis. in short, the flexibility of this object-oriented approach promotes the modification of the simulation as well as the analysis of the simulation's results.  richard j. greene