A Question of Reasonableness
How can we expect to succeed at things which others have tried and failed?
To say that a grounding in Rolonics Theory makes a difference is not good
enough, as Rolonics Theory contains nothing new. It is a composition of
ideas, some well known, some obscure. I do not doubt that Norman Kashdan is
a genius. But still there are no new ideas here. Indeed, many of the ideas
in Rolonic Theory can be found in other software. Journal-centric
programming is not entirely unknown. And
Wagn<http://www.wagn.org/wagn/Introduction>has come pretty close to
the idea of a Rolon.

Rolonics really is central to everything we are working on. Among other
things it addresses systems of systems (a rolon is both a system of parts
and a part of systems), which Systems Theory fails to do. The real question
then is, why is there no main-stream equivalent? My best guess is that the
lessons learned from software development have had little influence on
established philosophical thinking. Let me explain.

Software provides us a powerful tool for testing theories by modeling them.
Take a theory of astro-physics, develop a computer model and then model the
life of a star. The more correct the theory and the model, the greater the
correspondence between the behavior of the model and our observations about
the behavior of stars. This is pretty clear cut. No one confuses the model
for real stars.

But software can also be used to create new things in the world, a word
processor being a good example. This is not covered by established
philosophical thinking--bringing things into existence by describing them.
But note that people also work a bit like computers in this regard.
Memes<http://memes.org/>(ideas) are spread like viruses of the mind
and are the basis for social
evolution. A thought can be expressed and by this means conveyed to others,
and this is a creative process. Now there are schools of thought which deal
with creating things through expression, but historically they have not been
accepted as "good" philosophy. Cabala
<http://en.wikipedia.org/wiki/Cabala>is one example, ontological
invocation being the creation of something by
naming (describing) it. G. Spencer-Brown’s Laws of Form, which was popular
in the 60's (Whole Earth Catalog) being another. Unfortunately the idea of
creation through expression (software, mathematics and literature being
examples) is too close to traditional magic ("So mote it be";
"Abracadabra"--as I say it, so shall it be). And mainstream philosophy
avoids anything with the slightest taint of magic.

So we are left with Norman Kashdan's unpublished Rolonics Theory, which I
understand in small part and have used as the basis for Rolonic Software
Engineering. It has taken me years just to work out a reasonable model for
rolons (which Norm calls proto-rolons, as they do not have intention). I
will not say that I have done a good job at this--I am still learning. But
some interesting things have indeed come out of my efforts.

I see two major benefits of Rolonic Software Engineering. The first comes
from having a better model of things. OO provides a very limited model for
things, so every application must implement nearly every capability from
scratch. The consequence of this is incompatibilities between applications
at a very fundamental level. With the rich model provided by Rolonics
Theory, most capabilities can be implemented in the basic model rather than
being specific to an application. This gives rise to something
wonderful: Everything
Just Works Together<https://sourceforge.net/apps/trac/agilewiki/wiki/EverythingWorksTogether>
.

The second benefit of Rolonic Software Engineering is more anticipated than
realized just yet. Rolonics gives us a much better model for things,
especially living things, in the real world. Given an appropriate UI
(perhaps a desktop?), users should quickly grasp the nature of the rolons
modeled in the display, as they behave more reasonably and predictably (from
a user's perspective) than most other software. Since most capabilities are
handled by the common model which serves as the basis for all rolonic
applications, the user will not constantly be confronted
with incompatibilities and capabilities which exist for one type of rolon
and which do not (but logically should) exist for all other types of
rolons.

The biggest problem to date has been in developing a reasonable
implementation for rolons. A rolon can easily be expressed as an XML
document or even in JSON. But since a rolon carries its own history and may
also serve as a very large index for other rolons, rolons can be huge. This
is no problem for todays disk drives, but it does complicate the development
of the equivalent to an XML DOM.