OntoSimula consists of a simplified model of a "being as being". The underlying thought is, that beings are composed of "existentia" and "essentia", i.e. the "act of to be" and the limitation of this act by the nature of the being.
In our model the beings taken into consideration are philosophers and therefore have a generic nature as a philosopher and a very specific nature as an individual. The generic act of to be becomes very specific in an individual by being limited by the individual's specific nature.
The model illustrates the following metaphysical concepts:
- "existentia" or "esse" or "act-of-to-be"
- "essence in the wide sense",
- "essence in the strict sense (fully individuated essence)",
- "correlationship between 'act-of-to-be' and 'essence' "
- "first principle of identity" ('unum sequitur esse')
- "first principle of intelligibility" ('verum sequitur esse')
- "first principle of causality" (participated beings must be caused)
- "first principle of finality" ('omne agens agit propter finem' and 'bonum sequitur esse')
- "participated being"
- "change of essence" (by growing older for example),
- "freedom of person to make decisions" (the program is not deterministic).
- "analogy of being"
The nature of the individual as well as the generic nature is implemented in the model by "methods" in the context of object-oriented programming. Dynamic object-oriented programming (DOOP) is made possible in this implementation by a powerful "meta-object protocol". Due to the flexibility of the "mop" methods may be overloaded (polymorphism), methods may be deleted as well as new methods may be added dynamically. These features of the "mop" allow to represent "change" and "analogy" of "being".
The model even illustrates the concept of "participation" in that sense that all acts-of-to-be of limited beings are a participation of the act-of-to-be of the "absolute being" the "ipsum esse subsistens".
The programming language used, i.e. Scheme, has the unique power and expressiveness, providung "full continuations", to allow "sharing of the act of to be" with other beings.
Implementation of the Model:
If the program is run you just see a visualization of the life of a couple of philosophers. The relationship to metaphysics can be seen only by studying the implementation.
The Scheme implementation is used for the explanation because it is easier to understand. Understanding Java code requires more knowledge about the syntax of the language.
The Java implementation is covered in detail in the book: "Programmierung pur".
In the model we define a class "being" with a method "act-of-being".(define Being (make-nature-of "Being" ....))By doing this we define that all objects belonging to this class or all instances of it will share this property: "the act of existence". We will make sure that every object created will belong to this class "being".(defmethod act-of-being "Being" .....)
Normally we would have done the same with the component: "essence". We have indicated this by comments in the code. But because in our specific situation, at such a high level of abstraction nothing could have been specified as "essence" that would not be more appropriate on a lower level. It should be noted at this point, that there will never be objects in the program that are just "beings". They will always be something more specific as well, like in our case: "philosophers".
So we define another class called "philosopher". Note that the class definition for philosopher:(define Philosopher (make-nature-of "Philosopher" "Being" .....))contains a link to a so-called "parent" class, in this case "Being". This means that all instances of the class philosopher are by virtue of this fact also instances of class "Being". Therefore all "philosophers" have an "act-of-to-be".
The "essence" of a philosopher is now implemented by some so-called attributes and methods:As attributes of a "philosopher" we define:
As methods of a "philosopher" we define:
- "t-time" as the time spent thinking,,
- "e-time" the time needed for eating,
- "s-time" the time used for sleeping,
- "w-time" the time spent waiting for chopsticks,
- "k-time" the time having been sick,
- "ticks" the overall time in this little system, and finally
- "room" as the room in which the "philosopher" performs all his or her activities.
(defmethod get-chopsticks ....) (defmethod return-chopsticks ....) (defmethod think ....) (defmethod eat ....) (defmethod sleep ....) (defmethod sick ....) (defmethod think ....) (defmethod act-of-being ....) (defmethod select-pattern ...) (defmethod pattern-normal ...) (defmethod pattern-dedicated ...) (defmethod pattern-above-and-beyond ...) (defmethod pattern-moderate ...) (defmethod pattern-sick ...)
These methods define the potency of "philosophers", what they would be cabable of doing and which patterns of activity they would have available for selection, the acts they would have the potency to perform.
In our model it is not sufficent to define generic classes however, we need individuals, subjects, persons that are "philosophers" and therefore "beings". We achieve this by defining finally the nature of the desired persons:(define Parmenides (make-nature-of "Parmenides" "Philosopher" ...)) etc.Here we will find the definition of the fully individuated essence for each individual person. Note that many methods defined for a specific person were already defined for philosophers as such. The methods defined here for an individual have of course prevalence over methods defined on a higher level.The methods define the potency of a subject that limits the act-of-to-be.The definition that is closest to the subject will be effectively the subject's limiting factor. In "oop" terminlology we call this overloading of methods.
Relationship between "act-of-to-be" and "essence":
We have only defined one "method" "act-of-to-be" for all philosophers. But the code demonstrates very well that the "act-of-to-be" is not thinkable alone, as something independent from anything else.The "act-of-to-be" is constituted by the "essence" of the being.In the code the term "self" (suppositum) is seen at several points. This shows that the "suppositum" of the being is intimateley related with its corresponding "act-of-to-be".
A famous contemporary German philosopher, Hans-Eduard Hengstenberg, who is considered one of the three great phenomologists of our century (i.e. Edmund Husserl, Nicolai Hartmann and H.E.Hengstenberg), criticizes the duality of the Thomistic approach to ontology. He cannot see that the two components of a being "existentia" and "essentia" explain the "Wholeness" of the being. That is why he introduces three constitutive principles. The discussion of his ideas and the comparison with the Thomistic approach would need too much time and space to be inserted here.However we would like to point out that this little model seems to demonstrate well that the "wholeness" of the being, its standing out ("existence") against all other beings, is following without question from the Thomistic approach.
First Principle of Identity (unum sequitur esse):
The model also demonstrates that the "first principle of identity" is a direct consequence of the structure of the being:The "act-of-to-be" in conjunction with its correlated "suppositum" (called "self" in the code according to oop-terminology), univocally identifies the being.The "supreme being" in our model, that has to fill in for "ipsum esse subsistens" just triggers this "act-of-to-be" and the being comes into existence, stands out of nothingness and performs its functions including exercising its free will.
The corresponding code can be found in file "mdisp.scm":
The line: ((car b-queue) ...) triggers the act-of-to-be of a specific being.
In greater details: ;; the next being waiting to be taken out of "limbo" is retrieved from the queue by: "(car b-queue)". The triggering of the retrieved act is done by the second pair of parentheses: "((....))".
First Principle of Intelligibility (verum sequitur esse)
Of course such a principle must be the consequence in any computer simulation, because the code, representing the being, is always intelligible, or at least should be (to exercise the virtue most important for all programmers: humility).
First Principle of Causality (participated beings must be caused):
The model clearly demonstrates this principle: each "act-of-to-be" must be triggered by the "supreme being" in order to become an act.
We have already looked at the appropriate code:((car b-queue) ...)Without this act of sharing by the "supreme being" the philosopher in our simulation would not exist, could not perform his or her act-of-being.
First Principle of Finality (omne agens agit propter finem):
This principle is also demonstrated in the model, because the final end of all acts of the being taken together is very well defined by the code of the methods or functions, still leaving room for free decisions.
The code models free decisions by selection of patterns using random numbers.
That all "philosophers" in our model receive their "act-of-being" from the "supreme being" (look at the code in 'mdisp.scm') has already been shown.
Change of Being:
The model allows for a changing of the "essence", i.e. for modification of the limiting factors of the act of existence. The essence in the wide or in the strict sense is implemented as "methods" in oop-jargon.These methods can easily be deleted dynamically and new ones may be added at run-time. Methods can also be changed by overwriting the old ones.In our simulation we decided to modify the method "pattern-above-and-beyond" for two philosophers that have reached a certain age. This demonstrates that growing and decaying is fully within the scope of this approach.
(N.B. To implement these feature we needed Dynamic Object-Oriented Programming. That is the reason for extending Java by creating Dynamic Java (DJ-Min) ).
Potency to make free decisions:
Freedom of choice is simulated in this model by using random numbers to select one of the patterns of behaviour available to the individual. See method: "select-pattern" in file "ontosimula.scm". Here we will find right at the beginnning:(let* ((x (srand 1 16))...)and further down:(set! pattern (list-ref patterns (- x 1)))What these two lines do is principally the following: Using a random number generator a number is generated from 1 to 16. This random number is used to select a pattern(list-ref patterns ...)from a list of patterns that has been define above for this individual:(patterns (list ....))
Analogy of Being:
Even though the act-of-to-be is the same for all beings, we have only one method defined:(defmethod act-of-being "Philsopher" () ...)the act itself is performed by each individual in its own specific way.The being of all created beings is not the same, it is similar, i.e. analogous.
Resources used in building the implementation:
The implementation was strongly influenced by the following books:
- "Programmer avec Scheme" by Jacques Chazarain (meta-object protocol),
- "The Programming Language Scheme" by R.Kent Dybvig (multitasking)
- "Scheme and the Art of Programming" by George Springer and Daniel P. Friedman (algorithm for pseudo-random numbers)
- "A Little Smalltalk" by Timothy Budd ("Dining Philosophers Problem", originally introduced by Edsgar W. Dijkstra)
From the philosophical side the following books were referenced:
- "An Introduction to Philosophy" by Jacques Maritain and
- "Thomistic Metaphisics: An Enquiry into the Act of Existing" by Charles A. Hart
- "Sein und Urspruenglichkeit" by Hans-Eduard Hengstenberg "Beitraege zur Ontologie" by Hans-Eduard Hengstenberg.
Scenario of the application:The scenario consists of a certain number of philosophers that spend their day "thinking", "eating" and "sleeping" according to certain patterns of behavior that belong to their generic or their specific nature. They are free to decide, which pattern they want to follow on a specific day.
In order to be able to eat they need normally two chopsticks. There are only a limited number of chopsticks available on the table. If all chopsticks are in use a philosopher, wanting to eat, has to wait until a colleague is finished with his meal meal and returns his chopsticks to the table.
At the end of the simulation the program displays the times used by each philosopher for thinking, eating, sleeping and waiting for chopsticks. The "ticks" displayed as well represent the number of dispatch cycles used by the master program representing the "ipsum esse subsistens" sharing the "act of to be" with created beings.
In this simulation "Sokrates" is given the special skill to eat with just one chopstick. For this reason he never has to wait and will be the first to finish, unless he has selected inferior patterns of behaviour, which might require more dispatch cycles.
The graphical version illustrates the life of the philosophers in a separate window on the screen. The graphics are simple, because they are completeley programmed in Scheme (or Java) using just a line-drawing capability of the underlying system.
The states of the philosphers are represented by the following colors:
If a philospher asks for chopsticks and if there are enough available at the moment he gets them moved into his room. Upon termination of his meal he returns them to the central place.
- thinking: blue
- waiting for chopsticks: orange
- eating: red
- sleeping: black
- sick: green
Miscellaneous:The operator control panel can be used to speed up the simulation or to slow it down.Three speeds are available: slow, medium and fast.The operator can also turn off or turn on the trace of the messages displayed in the message window.
If the message trace is turned, on the viewer can monitor all actions of the philosophers in the text area below.The "Reset" key gives the operator the option to start another simulation.
Browse Scheme Source Files:
Home | ARS/A++ | Demonstration Programs
© 1999-2009 Georg P. Loczewski. All Rights Reserved.