Intelligent Objects: The Future of Simulation

2 THE SIMIO OBJECT PARADIGM

Simio is a simulation modeling framework based on intelligent objects. The intelligent objects are built by modelers and then may be reused in multiple modeling projects. Objects can be stored in libraries and easily shared. A beginning modeler may prefer to use pre-built objects from libraries, however the system is designed to make it easy for even beginning modelers to build their own intelligent objects for use in building hierarchical models.

An object might be a machine, robot, airplane, customer, doctor, tank, bus, ship, or any other thing that you might encounter in your system. A model is built by combining objects that represent the physical components of the system. A Simio model looks like the real system. The model logic and animation is built as a single step.

An object may be animated in 3D to reflect the changing state of the object. For example a forklift truck raises and lowers its lift, a robot opens and closes its gripper, and a battle tank turns its turret. The animated model provides a moving picture of the system in operation.

Objects are built using the concepts of object- orientation. However unlike other object oriented simulation systems, the process of building an object is very simple and completely graphical. There is no need to write programming code to create new objects.

The activity of building an object in Simio is identical to the activity of building a model -- in fact there is no difference between an object and a model. This concept is referred to as the equivalence principle and is central to the design of Simio. Whenever you build a model it is by definition an object that can be instantiated into another model. For example, if you combine two machines and a robot into a model of a work cell, the work cell model is itself an object that can then be instantiated any number of times into other models. The work cell is an object just like the machines and robot are objects. In Simio there is no way to separate the idea of building a model from the concept of building an object. Every model that is built in Simio is automatically a building block that can be used in building higher level models.

3 THE OBJECT ORIENTED FOUNDATION

Many popular programming languages such as C++, C#, and Java are all built around the basic principles of object oriented programming (OOP). In this programming paradigm software is constructed as a collection of cooperating objects that are instantiated from classes. These classes are designed using the core principles of abstraction, encapsulation, polymorphism, inheritance, and composition.

The abstraction principle can be summarized as focusing on the essential. The basic principle is to make the classes structure as simple as possible.

The encapsulation principle specifies that only the object can change its state. Encapsulation seals the implementation of the object class from the outside world.

Polymorphism provides a consistent method for messages to trigger object actions. Each object class decides how to respond to a specific message.

Inheritance is a key concept that allows new object classes to be derived from existing object classes: this is sometimes referred to as the "is-a" relationship. This is also referred to as sub-classing since we are creating a more specialized class of an object. Sub-classing typically allows the object behavior to be extended with new logic, and also modified by overriding some of the existing logic.

Composition allows new object classes to be built by combining existing object classes: this is sometimes referred to as the "has-a" relationship. Objects become building blocks for creating higher level objects.

It is interesting to note that the roots of these ideas date back to the early 1960's with the Simula 67 simulation modeling tool. This modeling tool was created by Kristen Nygaard and Ole-Johan Dahl (1962) of the Norwegian Computing Center in Oslo to model the behavior of ships. They introduced the basic concepts of creating classes of objects that own their data and behavior, and could be instantiated into other objects. This was the birth of hierarchical modeling and object-oriented programming.

Many people assume that object-oriented programming concepts were developed within the programming world; however this was not the case. These principles were developed for building simulation models, and then adopted by the programming world.

Although the simulation world created the original object-oriented concepts, it has yet to produce an object- oriented modeling framework that practitioners have widely embraced. Although there have been a number of attempts to provide such a framework, in the end practitioners have for the most part stuck to their proven process orientation for modeling. One of the big reasons for this is that most past attempts have simply been object- oriented programming libraries that require the user to step back in time 25 years and again code their models and/or objects in a programming language.