[MUD-Dev] OpenCyc, design implications of ontological systems?
bruce at cubik.org
Thu Apr 4 01:11:14 New Zealand Daylight Time 2002
Something that I've been interested in for a while are ontological
systems (from the AI, not philosophical perspective):
Today (finally!), OpenCyc had their first beta release (for Linux
only at this point, but Windows by 1.0):
Some explanation though ...
An ontology is a specification of what exists within a system
and what is true about those things.
According to the Stanford Knowledge Systems Laboratory :
"An ontology is an explicit specification of some topic. For
our purposes, it is a formal and declarative representation
which includes the vocabulary (or names) for referring to the
terms in that subject area and the logical statements that
describe what the terms are, how they are related to each
other, and how they can or cannot be related to each
other. Ontologies therefore provide a vocabulary for
representing and communicating knowledge about some topic and a
set of relationships that hold among the terms in that
Some further explanation can be found at:
You could view the item hierarchy (if you have one) of a mud as the
start of an ontology in a primitive form. Those who have read _Game
Architecture and Design_ by Rollings and Morris may be familiar with
their discussion of the tokenization of a game design (Chapter 17 I
think). That's also like an ontology.
Something that I've noticed when working on The Eternal City and
some other projects is that a lot of what I'm writing is something
that I think I should be able to just write as a couple of logic
statements and let the system handle it.
Instead of having to spread rules out into the code, and modify the
Ostrich object to prevent it from being able to fly, I could state
it as a rule, with [Rule1] corresponding to the rule that states
that birds are able to fly:
(#$exceptWhen (#$isa ?BIRD #$Ostrich) [Rule1])
or, in English:
Birds can fly, except when the bird is an ostrich.
And, from that, rather than checking all of those rules at runtime,
have the ontological system output a body of code that implements
the ruleset, including the correct inheritance relations and any
properties and methods that are necessary.
There's some research being done in that direction by Kris De
"My main research interests are in the area of
programming-language design. I am mostly working on applying
logic meta programming to programs written in procedural and
object-oriented programming languages, mainly for the purpose
of achieving higher degrees of genericity and better separation
of concerns through code generation.
"From the work I have done on this, I believe it is a very
powerful and interesting combination of programming paradigms
which complement each other in many ways. It allows a very high
degree of abstraction and genericity in program code in
comparison to 'plain' procedural or object-oriented
programming. The biggest challenge in this research is to make
it not just powerful, but also easy and natural to use in day
to day programming."
In writing complex systems with a lot of interactions between the
components, consistency is much more difficult, especially when the
implementation of the logic is scattered throughout the
source. Centralizing the logic and providing a simpler, more
straightforward way to edit that logic, and with the addition of
tools to validate the logical structure, would make the construction
of the more complex interactions simpler and (hopefully) more
Another possible advantage to that sort of set up is that it might
allow for any AI that you have to have a straightforward way of
querying the knowledge base (ontology) to use that information (that
also defines the nature of the game world) in making decisions.
Has anyone gone down this path or been looking into similar things?
MUD-Dev mailing list
MUD-Dev at kanga.nu
More information about the MUD-Dev