3D Behavioral Model Design for Simulation and Software Engineering∗

Paul A. Fishwick

University of Florida

November 24, 1999

Abstract

Modeling is used to build structures that serve assurrogates for other objects. As children, we learn tomodel at a very young age. An object such as a smalltoy train teaches us about the structure and behaviorof an actual train. VRML is a file standard for repre-senting the structure of objects such as trains, whilethe behavior would be represented in a computer lan-guage such as ECMAScript or Java. VRML is an ab-breviation for Virtual Reality Modeling Language [2],which represents the standard 3D language for theweb. Our work is to extend the power of VRML sothat it is used not only for defining shape models, butalso for creating structures for behavior. “Behaviorshapes” are built using metaphors mapped onto well-known dynamic model templates such as finite statemachines, functional block models and Petri nets.The low level functionality of the design still requiresa traditional programming language, but this levelis hidden underneath a modeling level that is visual-ized by the user. We have constructed a methodol-ogy called rube which provides guidelines on buildingbehavioral structures in VRML. The result of our en-deavors has yielded a set of VRML Prototypes thatserve as dynamic model templates. We demonstrateseveral examples of behaviors using primitive shapeand architectural metaphors.

1 INTRODUCTION

One physical object captures some information aboutanother object. If we think about our plastic toys,metal trains and even our sophisticated scale-basedengineering models, we see a common thread: tobuild one object that says something about another—usually larger and more expensive—object. Let’s callthese objects the source object and the target object.Similar object definitions can be found in the litera-ture of metaphors [6] and semiotics [10]. The source

∗Department of Computer & Information Science and En-gineering, P.O. Box 116120, Gainesville, FL 32611, Email:fishwick@cise.ufl.edu

object models the target, and so, modeling representsa relation between objects. Often, the source objectis termed the model of the target. We have been dis-cussing scale models identified by the source and tar-get having roughly proportional geometries. Scale-based models often suffer from the problem wherechanging the scale of a thing affects more than justthe geometry. It also affects the fundamental lawsapplied at each scale. For example, the hydrodynam-ics of the scaled ocean model may be different thanfor the real ocean. Nevertheless, we can attempt toadjust for the scaling problems and proceed to un-derstand the larger universe through a smaller, moremanipulable, version.

Our task is to construct a software architecturethat encourages 3D construction of objects and theirmodels. Our focal point is the behavioral model whereone defines the behavior or dynamics of an objectusing another set of objects. This sort of modelingmay be used in representing the models of large-scalesystems and software in the case where models havebeen used to specify the requirements and programdesign [1, 11]. We call this modeling architecturerube. An example use of rube is defined in the Sec. 2,and the methodology of rube in Sec. 3. Facets of theVRML implementation are defined in Secs. 4, 5 and6. We close the paper with philosophical issues on theart of modeling in Sec. 7 and the summary in Sec. 8.

2 NEWELL’S TEAPOT

In the early days of computer graphics (c. 1974-75),Martin Newell rendered a unique set of Bezier surfacespline patches for an ordinary teapot, which currentlyresides in the Computer Museum in Boston. Theteapot was modeled by Jim Blinn and then renderedby Martin Newell and Ed Catmull at the Universityof Utah in 1974. While at this late date, the teapotmay seem quaint, it has been used over the years asan icon of sorts, and more importantly as a bench-mark for all variety of new techniques in renderingand modeling in computer graphics. The Teapot wasrecently an official emblem of the 25th anniversary

7

Figure 1: Office scene with Newell Teapot, dynamicmodel and props.

of the ACM Special Interest Interest Group on Com-puter Graphics (SIGGRAPH).

Since 1989 at the University of Florida, we haveconstructed a number of modeling and simulationpackages documented in [4, 3] In late 1998, we starteddesigning rube, named in dedication to Rube Gold-berg [8], who produced many fanciful cartoon ma-chines, all of which can be considered models of be-havior. One of our goals for rube was to recognize thatthe Teapot could be used to generate another poten-tial benchmark—one that captured the entire teapot,its contents and its models. The default teapot has nobehavior and has no contents; it is an elegant piece ofgeometry but it requires more if we are to constructa fully digital teapot that captures a more completeset of knowledge. In its current state, the teapot isanalogous to a building facade on a Hollywood filmstudio backlot; it has the shape but the whole entityis missing. In VRML, using the methodology previ-ously defined, we built TeaWorld in Fig. 1. We haveadded extra props so that the teapot can be visual-ized, along with its behavioral model, in a reasonablecontextual setting. The world is rendered in Fig. 1using a web browser. World is the top-most root ofthe scene graph. It contains a Clock, Boiling System,and other objects such as the desk, chairs, floor andwalls. The key fields in Fig. 2 are VRML nodes of therelevant field so that the contains field refers to mul-tiple nodes for its value. This is accomplished usingthe VRML MFNode type. The hierarchical VRMLscene graph for Fig. 1 is illustrated in Fig. 2. Thescene contains walls, a desk, chair and a floor forcontext. On the desk to the left is the teapot whichis filled with water. The knob controlling whetherthe teapot heating element (not modeled) is on or offis located in front of the teapot. To the right of theteapot, there is a pipeline with three machines, eachof which appears in Fig. 1 as a semi-transparent cube.

World

Clock Boiling_System Furniture Floor Walls

Knob Water ThermometerPipeline

Machine1 Machine2 Machine3

Plant

Tank1

Tank2

Tank3 Pipe1

Pipe2

Pipe3

Pipe4

Board1

Board2

Board3

contains

functions

contains

states transitions

Clock

be be be

be

be

be

be

Figure 2: VRML Scene Graph for the Teapot and itsmodels.

Each of these machines reflects the functional behav-ior of its encapsulating object: Machine1 for Knob,Machine2 forWater andMachine3 for Thermometer.The Thermometer is a digital one that is positionedin Machine3, and is initialized to an arbitrary ambi-ent temperature of 0◦ C. Inside Machine2, we find amore detailed description of the behavior of the wa-ter as it changes its temperature as a result of theknob turning. The plant inside Machine2 consists ofTank1, Tank2, Tank3, and four pipes that move infor-mation from one tank to the next. Inside each tank,we find a blackboard on which is drawn a differentialequation that defines the change in water tempera-ture for that particular state. The following model-ing relationships are used: Pipeline is a FunctionalBlock Model (FBM), with three functions (i.e., ma-chines); Machine is a function (i.e., semi-transparentcube) within an FBM; Plant is a Finite State Machine(FSM) inside of Machine 2; Tank is a state within aFSM, and represented by a red sphere; Pipe is a tran-sition within a FSM, and represented by a green pipewith an attached cone denoting direction of controlflow; and Board is a differential equation, representedas white text. The following metaphors are defined inthis example. The three cubes represent a sequenceof machines that create a pipeline. One could haveeasily chosen a factory floor sequence of numericallycontrolled machines from the web and then used this

8

Figure 3: Pipeline closeup.

in TeaWorld to capture the information flow. Insidethe second machine, we find a plant, not unlike apetroleum refinery with tanks and pipes.

The Pipeline and its components represent phys-ical objects that can be acquired from the web.For our example, we show simple objects but theyhave been given meaningful real-world application-oriented names to enforce the view that one ob-ject models another and that we can use the webfor searching and using objects for radically differ-ent purposes than their proposed original function.The overriding concern with this exercise is to per-mit the modeler the freedom to choose any objectto model any behavior. The challenge is to choose aset of objects that provide metaphors that are mean-ingful to the modeler. In many cases, it is essen-tial that more than one individual understand themetaphorical mappings and so consensus must bereached during the process. Such consensus occursroutinely in science and in modeling when new mod-eling paradigms evolve. The purpose of rube is notto dictate one model type over another, but to allowthe modelers freedom in creating their own modeltypes. In this sense, rube can be considered a meta-level modeling methodology.

The simulation of the VRML scene shown inFig. 2 proceeds using the dashed line thread that be-gins with the Clock. The clock has an internal timesensor that controls the VRML time. The thread cor-responds closely with the routing structure built forthis model. It starts at Clock and proceeds downwardthrough all behavioral models. Within each behav-ioral model, routes exist to match the topology ofthe model. Therefore, Machine1 sends informationto Machine2, which accesses a lower level of abstrac-tion and sends its output to Machine3, completingthe semantics for the FBM. The FSM level containsroutes from each state to its outgoing transitions.

Fig. 3 shows a closeup view of the pipeline, thatrepresents the dynamics of the water, beginning withthe effect of turning of the knob and ending withthe thermometer that reads the water temperature.Figs. 4 through 6 show the pipeline during simula-

Figure 4: Cold state.

Figure 5: Heating state.

Figure 6: Cooling state.

tion when the knob is turned ON and OFF at randomtimes by the user. The default state is the cold state.When the knob is turned to the OFF position, thesystem moves into the heating state. When the knobis turned again back to the OFF position, the systemmoves into the cooling state and will stay there untilthe water reaches the ambient temperature at whichtime the system (through an internal state transition)returns to the cold state. Temperature change is in-dicated by the color ofWater and Machine3, in addi-tion to the reading on the Thermometer inside ofMa-chine3. The material properties of Machine1 changedepending on the state of the knob. When turnedto the OFF position, Machine1 is semi-transparent.When turned on, it turns opaque. Inside Machine2,the current state of the water is reflected by the levelof intensity of each Plant. The current state has anincreased intensity, resulting in a bright red sphere.

The dynamics of temperature is indicated at two

9

Figure 7: Outside the Heating phase.

Figure 8: Inside the Heating phase.

levels. At the highest level of the plant, we have athree state FSM. Within each state, we have a differ-ential equation. The equation is based on Newton’sLaw of Cooling and results in a first order exponen-tial decay and rise that responds to the control inputfrom the knob. The visual display of temperaturechange confirms this underlying dynamics since theuser finds the temperature changing ever more slowlywhen heating to 100◦C or cooling back to the ambienttemperature. Fig. 7 displays a closeup of the heat-ing phase from the outside, and Fig. 8 is a view frominside the red sphere modeling the phase.

3 rube Methodology

The procedure for creating models is defined as fol-lows:

1. The user begins with an object that is to be mod-eled. This object can be primitive or complex—such as a scene–with many sub-objects. In thecase of the teapot, we identify the teapot, water,knob, heating element as well as other aspectsof the environment: room, walls, desk and floor.Not all of these objects require embedded behav-

ioral models; some objects are props or exist forcontextual reasons.

2. The scene and object interactions are sketchedin a story board fashion, as if creating a movieor animation. A scene is where all objects, in-cluding those modeling others, are defined withina VRML file. The rube model browser is madeavailable so that users can “fly though” an ob-ject to view its models without necessarily clut-tering the scene with all objects. However, hav-ing some subset of the total set of models sur-faced within a scene is also convenient for aes-thetic reasons. The modeler may choose to buildseveral scenes with models surfaced, or chooseto view objects only through the model browserthat hides all models as fields of VRML objectnodes. In Fig. 1, the object Pipeline models theheating and cooling of the water, which is insidethe teapot to the left of Pipeline. We could alsohave chosen to place a GUI behavioral modelhandle for the teapot inside the teapot itself orwithin close proximity of the teapot.

3. The shape and structure of all objects are mod-eled in any modeling package that has an ex-port facility to VRML. Most packages, such asKinetix 3DStudioMax and Autodesk AutoCADhave this capability. Moreover, packages such asCosmoWorlds and VRCreator can be used to di-rectly create and debug VRML content. We usedCosmoWorlds for the walls, floor and Pipeline.Other objects, such as the teapot, desk and chairwere imported from the web.

4. VRML PROTO (i.e., prototype) nodes are cre-ated for each object, model and componentsthereof. This step allows one to create seman-tic attachments so that we can define one ob-ject to be a behavioral model of another (usinga behavior field) or to say that the water is con-tained within the teapot. Without prototypes,the VRML file structure lacks semantic relationsand one relies on simple grouping nodes, whichare not sufficient for clearly defining how objectsrelate to one another. PROTOs are created forall physical objects, whether or not the objectsare role-playing as a behavior model or as a be-havior model component. This is discussed inmore depth in Sec. 4.

5. Models are created. While multiple types ofmodels exist, we have focused on dynamic mod-els of components, and the expression of thesecomponents in 3D. Even textually-based mod-els that must be visualized as mathematical ex-pressions can be expressed using the VRML text

10

node. Models are objects in the scene that areno different structurally from pieces of visible ob-jects being modeled—they have shape and struc-ture. The only difference is that when an ob-ject is “modeling” another, one interprets theobject’s structure in a particular way, using adynamic model template for guidance.

6. Several dynamic model templates exist. ForNewell’s Teapot (in Sec. 2), we used three: FBM,FSM, and EQN. These acronyms are defined asfollows: FSM = Finite State Machine; FBM =Functional Block Model; EQN = Equation Set.Equations can be algebraic, ordinary differential,or partial differential. The FBM serves to cap-ture the control flow from the activity of theknob to the temperature change of the water,and on to the thermometer. The FSM insideMachine2 of Pipeline models the water temper-ature changes.

7. The creative modeling act is to choose a dy-namic model template for object behavior, andthen to pick objects that will convey the mean-ing of the template within the scenario. Thispart is a highly artistic enterprise since literallyany object can be used. It is not the policy ofrube to recommend or insist upon one metaphor.In practice, different groups will evolve and cer-tain metaphors may compete in a process akinto natural selection. Our Pipeline could easilyhave been more artistically modeled so that itappeared more as a pipeline, and so the Plantlooked more like an industrial plant. We werecaught between trying to employ metaphor toits fullest extent and wanting those familiar withtraditional 2D behavior models to follow the rubemethodology.

8. There are three distinct types of roles playedby modelers in rube. At the lowest level,there is the person creating the model templates(FSM,FBM,EQN,PETRI-NET). Each dynamicmodel template reflects an underlying system-theoretic model [5]. At the mid-level, the per-son uses an existing model template to create ametaphor. An industrial plant is an example ofa manufacturing metaphor. At the highest level,a person is given a set of metaphors and canchoose objects from the web to create a model.These levels allow modelers to work at the lev-els where they are comfortable. Reusability iscreated since one focuses on the level of interest.

9. The simulation proceeds by the modeler creat-ing threads of control that pass events from oneVRML node to another. This can be done in one

of two ways: 1) using VRML Routes, or 2) us-ing exposed fields that are accessed from othernodes. Method 1 is familiar to VRML authorsand also has the advantage that routes that ex-tend from one model component to an adjacentcomponent (i.e., from one state to another orfrom one function to another) have a topolog-ical counterpart to the way we visualize infor-mation and control flow. The route defines thetopology and data flow semantics for the simula-tion. Method 2 is similar to what we find in tra-ditional object-oriented programming languageswhere information from one object is made avail-able to another through an assignment statementthat references outside objects and classes. Suchan assignment is termed “message passing.” Inmethod 1, a thread that begins at the root nodeproceeds downward through each object that isrole-playing the behavior of another. The rout-ing thread activates Script nodes that are em-bedded in the structures that act as models ormodel components for the behaviors. All objectsacting as behavioral model components are con-nected to a VRML clock (i.e., TimeSensor) sothat multimodeling is made possible by allowingmodel components to gain control of the simula-tion and proceed in executing lower level modelsemantics.

10. Pre- and Post-processing is performed on theVRML file to check it for proper syntax andto aid the modeler. Pre-processing tools in-clude wrappers (that create a single VRMLfile from several), decimators (that reduce thepolygon count in a VRML file), and VRMLparsers. The model browser mentioned earlieris a post-production tool, allowing the user tobrowse all physical objects to locate objects thatmodel them. In the near future, we will ex-tend the parser used by the browser to helpsemi-automate the building of script nodes. Thebrowser and underlying VRML parser is basedin Java (using JavaCUP) and therefore can beactivated through the web browser.

rube treats all models in the same way. For aclarification of this remark, consider the traditionaluse of the word “Modeling” as used in everydayterms. A model is something that contains attributesof a target object, which it is modeling. Whereas,equation and 2D graph-based models could be viewedas being fundamentally different from a commonsensemodel, rube views them in exactly the same context:everything is an object with physical extent and mod-eling is a relation among objects. This unification istheoretically pleasing since it unifies what it means

11

to “model” regardless of model type. We are able tounify the commonsense view of modeling (i.e., scaleor clay models) with more abstract modeling tech-niques used on the computer.

4 VRML IMPLEMENTATION OF THETEAPOT

Newell’s Teapot has the VRML scene graph struc-ture as shown in Fig. 2, but there are also key proto-type definitions used for objects and the models. Thestructure of the PROTOs are as follows. First, wehave the PROTO for the dynamic model type FSM(Finite State Machine):

EXTERNPROTO FSM [eventIn SFFloat set_clockfield SFVec3f positionexposedField SFBool inputeventIn SFString set_statefield SFNode start_statefield MFNode soundsfield MFNode statesfield MFNode transitionsfield SFBool passivefield MFNode active

] "fsm.wrl#FSM"

The FSM is composed of states and transitions,with each state having a sound. There is astart state and a position for placing the FSMin the scene. set clock is the clock input and al-lows the FSM to take its input to drive the statetransition changes.

Each FSM may be modeled at one of two lev-els: active and passive. The use of the 3 tanksand 4 pipes is passive since there is no motion–onlya change in intensity of each tank when a state is en-abled. An active mode implies the existence of twoextra nodes, a mover and a path, both of which de-fine the geometry associated with an object movingalong a path. For example, if active has a field valueof [avatar24 spline3] then node avatar24 wouldmake a motion along a physical path defined by nodespline3 to denote a change in state.

EXTERNPROTO FSM_STATE [eventIn SFFloat set_clockexposedField SFBool enabledfield MFNode audioexposedField MFNode geometryfield MFNode behavior

] "fsm.wrl#FSM_STATE"

Each state and transition has a geometry model anda behavior mode. The geometry model is that whichdefines how the object is to be rendered. The be-havior model defines how the state is to be executed.behaviormay terminate in a VRML Script node, butmay also be further defined by another 3D structureto any abstraction level. Using geometry, we mayallow any 3D scene or object to reflect the notion ofstate.

EXTERNPROTO FSM_TRANSITION [eventIn SFFloat set_clockexposedField SFBool enabledeventOut SFString state_changedfield SFNode fromfield SFNode tofield SFNode fsmfield SFNode objectexposedField MFNode geometryfield MFString behavior

] "fsm.wrl#FSM_TRANSITION"

The transition nodes are similar in that one may as-sign both geometry and behavior to them. Eachtransition has from and to states. The transition alsocarries the behavior “logic” that determines whethera state change occurs.

The metaphor elements are mapped directlyto model templates, each of which is defined by aPROTO node:

• Industrial Plant metaphor → Finite state ma-chine → FSM PROTO

• Tank (in Plant) metaphor → State → FSM-STATE PROTO

• Pipe (in Plant) metaphor→ Transition→ FSM-TRANSITION PROTO

5 PROGRAMMING USING VRML

Object-Oriented Software engineering has long advo-cated the use of modeling in defining the creation ofsoftware. A recent example is the significant interestin the Unified Modeling Language (UML) [12, 9]. Theembedded nature of software encourages the model-ing approach since the design reflects the distributednature of the hardware components. Software engi-neers evolve into system modelers. Using VRML, wecreated a small operating system kernel that involvesmetaphors for tasks (using avatars), routes throughthe system (using colored paths) and resources (us-ing office desks with attendants). The overall oper-ating system is shown as an office building in Fig. 9

12

and inside the building there is a floor designatedas the kernel (Fig. 10). Tasks begin in a waiting

Figure 9: The operating system structure.

Figure 10: Inside the O/S kernel.

area on the left side of Fig. 10 and proceed to theCPU desk. Tasks continue to move toward the keyresources (DEVice, COMmunications,MEMory,I/O).The paths to the resources are in orange and the re-turn paths back to the holding area are blue. Whena resource is requested, this begins an audio trackspecifying which resource is being used.

6 VRML ISSUES

We found VRML to be fairly robust for the task setside within rube but there are a number of issues thatneed to be resolved in the future. The most seriousissues, having an effect on rube, are delineated:

1. VRML needs a strong object-oriented (OO)structure with classes, inheritance, object in-stances and a capability for referring to a currentobject with a this field. We found it difficult tocreate a regional scoping of public variables, forexample, in allowing a component to gain accessto its parents fields. Instead, one has to exposea field to every other node. One side-effect of a

solid OO architecture would be that there wouldbe a distinct difference between defining a Nodeand creating one. The existing DEF both definesand creates.

2. Exposed fields should operate exactly as ifone were to specify an eventIn, field andeventOut. Several VRML texts suggest anequivalence, but in practice they are quite differ-ent. Currently, if one creates an exposedField,then one cannot define an eventIn for set-ting values in a script node using a function ofthe eventIn name. There are many instanceswhere it would be useful to use both methodsof access to an exposedField: 1) directly withnode.set field, or 2) indirectly with a routeusing set field as an eventIn within a scriptnode. Routes are useful in surfacing connectionsbetween one node and another, but prudent useof exposedFields (if they were more completelyimplemented) simplifies a spaghetti-like networkof routes.

3. Both forward and backward references to nodesshould be possible. Currently, one cannot spec-ify USE somenode unless it has already been de-fined with DEF. This may require a multi-passoption on parsing the VRML scene graph, whichwould slow the parsing but give the VRML au-thor the freedom to choose forward referencingwhere they may wish to implement it.

4. Scripting capabilities need to be expanded tosupport native code, and need to be consistentamong browsers in supporting Java in the Scriptnode and full implementations of Javascript. In-stead of being implementor options, they shouldbe required. Native code is essential if VRMLis to both compete with, expand upon and reuseother 3D software.

5. We found PROTO and EXTERNPROTO sup-port to be variable among VRML software de-velopers. Since these are among the most impor-tant node types in VRML, their implementationsshould be ubiquitous in all VRML modelers andsoftware support.

7 ART OF MODELING

Given the Newell Teapot scene, there are some keyissues which we should ask ourselves:

• Is it “just” a visualization? The work inrube provides visualization, but models such as

13

Newell’s Teapot demonstrate active modeling en-vironments whose existence serves an engineer-ing purpose and not only a post-project visual-ization purpose for outside visitors. This sort ofmodeling environment is needed from the verystart of a mission—as an integral piece of thepuzzle known as model design. There is littlequestion that this sort of production is useful forteaching purposes, but we also view this as aprecursor to next generation software engineer-ing. The power of VRML in this regard is thatit can be used to reinvent software engineeringthrough the surfacing of 3D models. It is onething to think of this as a visualization of anOperating System kernel, but it is quite anotherto call it the Operating System itself. We needto bridge this gap if we are to progress beyondtextual, linear programming styles.

• Is it economical? Is this a lot of work just tocreate an FSM? All 3D objects are reused andso can be easily grabbed from the web. The con-cept of reuse is paramount to the rube approachwhere the metaphor can be freely chosen andimplemented. Without the web, rube would notbe possible. 3D object placement can be just aseconomical as 2D object placement, but objectrepositories are required.

• What is the advantage? If we consider psy-chological factors, the 3D metaphor has signif-icant advantages. First, 3D spatially-specific ar-eas serve to improve our memory of the mod-els (i.e., mnemonics). Second, graphical user in-terfaces (GUIs) have shown that a human’s in-teraction with the computer is dramatically im-proved when the right metaphors are made avail-able. rube provides the environment for buildingmetaphors. One should always be wary of mixedmetaphors. We leave the ultimate decision to theuser group as to which metaphors are effective.A Darwinian-style of evolution will likely deter-mine which metaphors are useful and which arenot. Aesthetics plays an important role here aswell. If a modeler uses aesthetically appealingmodels and metaphors, the modeler will enjoythe work. It is a misconception to imagine thatonly the general populous will benefit from fullyinteractive 3D models. The engineers and scien-tist need this sort of immersion as well so thatthey can understand better what they are doing,and so that collaboration is made possible.

• Is this art or science? The role of the Fine Artsin science needs strengthening. With fully im-mersive models, we find that we are in need

of workers with hybrid engineering/art back-grounds. It is no longer sufficient to alwaysthink “in the abstract” about modeling. Effec-tive modeling requires meaningful human inter-action with 3D objects. So far, the thin veneer ofa scale model has made its way into our engineer-ing practices, but when the skin is peeled back,we find highly abstract code and text. If the in-ternals are to be made comprehensible (by any-one, most importantly the engineer), they mustbe surfaced into 3D using the powerful capabili-ties of metaphors [7, 6]. This doesn’t mean thatwe will not have a low level code-base. Two-dimensional metaphors and code constructs canbe mixed within the 3D worlds, just as we findthem in our everyday environments with the em-bedding of signs. At the University of Florida,we have started a Digital Arts and Sciences Pro-gram with the aim to produce engineers with amore integrated background. This backgroundwill help to produce new workers with creativemodeling backgrounds.

• What role does aesthetics play in modeling? It issometimes difficult to differentiate models usedfor the creation of pieces of art from those usedwith scientific purposes in mind. Models usedfor science are predicated on the notion that themodeling relation is unambiguously specified andmade openly available to other scientists. Model-ing communities generally form and evolve whilestressing their metaphors. In a very generalsense, natural languages have a similar evolu-tion. The purpose of art, on the other hand, is topermit some ambiguity with the hopes of causingthe viewer or listener to reflect upon the modeledworld. Some of the components in worlds suchas Fig. 1 could be considered non-essential mod-eling elements that serve to confuse the scien-tist. However, these elements may contribute toa more pleasing immersive environment. Shouldthey be removed or should we add additional ele-ments to please the eye of the beholder? In rube,we have the freedom to go in both directions, andit isn’t clear which inclusions or eliminations areappropriate since it is entirely up to the modeleror a larger modeling community. One can buildan entirely two dimensional world on a black-board using box and text objects, although thiswould not be in the spirit of creating immersiveworlds that allow perusal of objects and theirmodels.It may be that a select number of modelers mayfind the TeaWorld room exciting and pleasing,and so is this pleasure counterproductive to thescientist or should the scientist be concerned only

14

with the bare essentials necessary for unambigu-ous representation and communication? Visualmodels do not represent syntactic sugar (a termcommon in the Computer Science community).Instead, these models and their metaphors areessential for human understanding and compre-hension. If this comprehension is complementedwith a feeling of excitement about modeling, thiscan only be for the better. Taken to the ex-treme, a purely artistic piece may be one that isso couched in metaphor that the roles played byobjects isn’t clear. We can, therefore, imaginea kind of continuum from a completely unam-biguous representation and one where the rolesare not published. Between these two extremes,there is a lot of breathing space. Science can beseen as a form of consensual art where everyonetells each other what one object means. Agree-ment ensues within a community and then thereis a mass convergence towards one metaphor infavor of another.

8 SUMMARY

Effort to unify behavioral and software engineeringmodeling methodologies are useful, but we shouldalso have a way to express models more creativelyand completely. Model communities will naturallyevolve around 2D and 3D metaphors yet to be de-termined. rube has a strong tie to the World WideWeb (WWW). The web has introduced a remarkabletransformation in every area of business, industry,science and engineering. It offers a way of sharingand presenting multimedia information to a world-wide set of interactive participants. Therefore anytechnology tied to the web’s development is likely tochange modeling and simulation. The tremendous in-terest in Java for doing simulation has taken a firmhold within the simulation field. Apart from being agood programming language, its future is intrinsicallybound to the coding and interaction within a browser.VRML, and its X3D successor, represent the futureof 3D immersive environments on the web. We feelthat by building a modeling environment in VRMLand by couching this environment within standardVRML content, that we will create a Trojan Horsefor simulation modeling that allows modelers to cre-ate, share and reuse VRML files.

Our modeling approach takes a substantial de-parture from existing approaches in that the mod-eling environment and the material object environ-ment are merged seamlessly into a single environ-ment. There isn’t a difference between a circle anda house, or a sphere and a teapot. Furthermore, ob-

jects can take on any role, liberating the modeler tochoose whatever metaphor that can be agreed uponby a certain community. There is no single syntaxor structure for modeling. Modeling is both an artand a science; the realization that all objects can playroles takes us back to childhood. We are building rubein the hope that by making all objects virtual thatwe can return to free-form modeling of every kind.Modeling in 3D can be cumbersome and can take con-siderable patience due to the inherent user-interfaceproblems when working in 3D using a 2D screen in-terface. A short term solution to this problem is todevelop a model package that is geared specifically tousing one or more metaphors, making the insertionof, say, the petroleum refinery a drag and drop opera-tion. Currently, a general purpose modeling packagemust be used to carefully position all objects in theirrespective locations. A longer term solution can befound in the community of virtual interfaces. A goodimmersive interface will make 3D object positioningand connections a much easier task than it is today.

ACKNOWLEDGMENTS

We would like to thank the students on the rubeProject: Robert Cubert, Andrew Reddish, John Hop-kins and Linda Dance. Also, we thank the followingagencies that have contributed towards our study ofmodeling and simulation: (1) Jet Propulsion Lab-oratory under contract 961427 An Assessment andDesign Recommendation for Object-Oriented Physi-cal System Modeling at JPL (John Peterson, StephenWall and Bill McLaughlin); (2) Rome Laboratory,Griffiss Air Force Base under contract F30602-98-C-0269 A Web-Based Model Repository for Reusing andSharing Physical Object Components (Al Sisti andSteve Farr); and (3) Department of the Interior un-der grant 14-45-0009-1544-154 Modeling Approaches& Empirical Studies Supporting ATLSS for the Ev-erglades (Don DeAngelis and Ronnie Best). We aregrateful for their continued financial support.

References

[1] Grady Booch. Object Oriented Design. Ben-jamin Cummings, 1991.

[2] Rikk Carey and Gavin Bell. The AnnotatedVRML 2.0 Reference Manual. Addison-Wesley,1997.

[3] Robert M. Cubert and Paul A. Fishwick.MOOSE: An Object-Oriented Multimodelingand Simulation Application Framework. Sim-ulation, 70(6):379–395, 1998.

15

[4] Paul A. Fishwick. Simpack: Getting Startedwith Simulation Programming in C and C++. In1992 Winter Simulation Conference, pages 154–162, Arlington, VA, 1992.

[5] Paul A. Fishwick. Simulation Model Design andExecution: Building Digital Worlds. PrenticeHall, 1995.

[6] George Lakoff. Women, Fire and DangerousThings: what categories reveal about the mind.University of Chicago Press, 1987.

[7] George Lakoff and Mark Johnson. MetaphorsWe Live By. University of Chicago Press, 1980.

[8] Peter C. Marzio. Rube Goldberg, His Life andWork. Harper and Row, New York, 1973.

[9] Pierre-Alain Muller. Instant UML. Wrox Press,Ltd., Olton, Birmingham, England, 1997.

[10] Winfried Noth. Handbook of Semiotics. IndianaUniversity Press, 1990.

[11] James Rumbaugh, Michael Blaha, William Pre-merlani, Eddy Frederick, and William Lorenson.Object-Oriented Modeling and Design. PrenticeHall, 1991.

[12] James Rumbaugh, Ivar Jacobson, and GradyBooch. The Unified Modeling Language Refer-ence Manual. Addison-Wesley, Reading, MA,1999.

AUTHOR BIOGRAPHY

PAUL FISHWICK is Professor of Computer andInformation Science and Engineering at the Univer-sity of Florida. He received the PhD in Computer andInformation Science from the University of Pennsyl-vania in 1986. His research interests are in computersimulation, modeling, and animation, and he is a Fel-low of the Society for Computer Simulation (SCS).Dr. Fishwick will serve as General Chair for WSC00in Orlando, Florida. He has authored one textbook,co-edited three books and published over 100 techni-cal papers.

Permission to make digital or hard copies of part of all of this work or personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. To copy otherwise, to republish, to post on servers, or to redistribute to lists, requires prior specific permission and/or a fee. VRML 2000, Monterey, CA USA © ACM 2000 1-58113-211-5/00/02 � $5.00

16