[FRIAM] Fwd: ABM (Object-Oriented)

Sun Jun 3 18:35:15 EDT 2007

Marko (and Russell Standish),

In Graph Theory, you have circles and lines (i.e. nodes and edges, or
vertices and connections).

It is possible to have circles and no lines, but not the converse. This is
because every line presupposes two circles—one on each end of the line. The
two circles can be the same circle (i.e. a reflexive line) but in this case,
that circle is playing two roles: FROM and TO (or source and sink).

PROOF: If you look at the definition of a graph in the PDF
<http://www.soe.ucsc.edu/~okram/papers/semantic-turing.pdf>  you sent or on
Wiki <http://en.wikipedia.org/wiki/Graph_%28mathematics%29> , it says V is a
set of vertices, and E ? V X V is a set of edges. Well, every subset
presupposes a superset. QED.

As mentioned previously, and for the same causal relationship, dynamics
presuppose statics. If your goal is to model the dynamics (you used the term
“procedural aspects”), then first model the statics (you used the term
“structural aspects”).

When I try to fit the definition and uses of “objects” as per the semantic
web into my own paradigm, I get contradictions. As I define:

An object is two parts: a static part and a dynamic part.

Although mathematics is the first object-oriented language (practically
perfected at inception), the computer industry has really convoluted the
definitions to the point where nobody know what anyone is talking about
these days.

Computers bestow the concept of “lifetime” to objects. Computers create
objects in memory, and then dispose of them when no longer needed only to
create different objects later at the same identity. We almost take this for
granted!

Mathematics does not have this concept of lifetime. In fact, the Platonic
philosophy imagines the number “7” as something that just exists out there
timeless, immutable, and consistent, where its identity equals its class and
state. Its identifier maps bijectively to its identity. Its name is its
value. However, computer objects pop into existence during the execution of
some system and pop right back out. I can’t help but think about virtual
particles (or for that matter, universe bubbles) popping in and out of the
space of all things possible. When the program ends, the universe ends too. 

Mathematicians are “inside” the world of mathematics whereas computer
programmers are “outside” the world of computers. It should be no wonder
that historically, the best theories of physics: Newtonian, Relativity,
Quantum, come when we move our godlike egos from outside to inside. Perhaps
computer programmers are the last bastion fighting the wave of humility.
Bekenstein’s Theory of Information suggests that they are starting to come
inside.

I just bought Russell Standish’s book “The
<http://www.amazon.com/Theory-Nothing-Russell-Standish/dp/1921019638>
Theory of Nothing” after reading the cover. I’m always looking (mostly in
vain) for someone else’s perspective on what I think I understand but cannot
express: that our multiverse is the superposition of all consistent
solutions (or family of curves) that sum to zero. That’s how you get
something from nothing. I have high hopes with this book. Still waiting for
it to come!

Anyway, the physical limitations of finite computers force us to partition
the static part of an object into two parts: its class and its identity. The
dynamic part of an object is still called its state.

In the world of computers, an object’s class is the static set of immutable
rules that the object always conforms to – even before the object was
created and long after it’s destroyed. This set of rules, called a category
<http://en.wikipedia.org/wiki/Category_theory>  in mathematics, acts as a
set generator for other objects—a method to instantiate different objects
from the same class. An object’s identity is the static part that is created
at the same time the object is created and remains immutable during the
lifetime of that object. The number one source of bugs in any data system
occurs when an object’s identity changes during its lifetime. Think of links
to a web page that changes its content, or moves. 404 Error – File Not
Found!

The dynamics of a computer object are the methods (i.e. contained functions)
that transform its internal values from one state to another while keeping
its class and identity intact (sort of like eigenvectors are to a
mathematical matrix operator).

Again, this concept does not exist in mathematics. Given F(X) = 3*X, then
F(7) = 21. Yes, we call F a function or a transform, but it did not “turn” a
7 in 21. It functionally mapped a 7 to a 21. The 7 never changed and didn’t
notice anything. Where our space of focus once contained only a 7, applying
F added a 21 to our space—not changed a 7 into a 21.

Good luck trying to model dynamics in the semantic web. Unfortunately, in
the semantic web, an object’s identity is subtly destroyed when transformed
– it’s overwritten. There is no symmetry between an object’s identity and
its state in the semantic web. 

Robert Howard
Phoenix, Arizona

  _____  

From: friam-bounces at redfish.com [mailto:friam-bounces at redfish.com] On Behalf
Of Marko A. Rodriguez
Sent: Sunday, June 03, 2007 12:03 PM
To: The Friday Morning Applied Complexity Coffee Group
Subject: Re: [FRIAM] Fwd: ABM (Object-Oriented)

Hi,

I've been dealing with this issue in semantic networks. Semantic networks
tend to be used for "descriptive" purposes. This is analogous to the
structural aspects of a system. However, I've been interested in encoding
the more "procedural" aspects of a system into the semantic network.

http://www.soe.ucsc.edu/~okram/papers/semantic-turing.pdf

BTW: I really enjoyed that last email. Its nice to see this strong
distinction in other domains as well.

Marko.

On Jun 3, 2007, at 1:34 PM, Robert Lancaster wrote:

Many thanks for the best distinction of structural and object oriented
languages I have ever seen.  Big help for someone with a very elementary
understanding of the art.  (I had just read the WIKI definition with the
result which you predict.)

Bob L. 

On Jun 2, 2007, at 11:50 AM, Robert Howard wrote:

That WIKI <http://en.wikipedia.org/wiki/Object-oriented_programming>
definition will leave you confused if you’re learning OO for the first time.

Here’s a hard physical-sciences analogy:

*	In physics, you have Statics and Dynamics. 
*	In biology, you have Anatomy and Physiology.
*	In molecular biology, you have Structure and Function.
*	In languages, you have Nouns and Verbs.
*	In chaos theory, you have the system (e.g. a differential equation),
and its phase space <http://en.wikipedia.org/wiki/Phase_space> .
*	In general, you have the part that doesn’t change, and the part that
does.

In computers, you also have the part that doesn’t change. Depending on the
vernacular context, these static parts are called a Types, Structures,
Schema, Address locations, Code/Instruction Libraries, and Classes.

You also have the part that does change. Again, depending on the circle of
nomenclature, these dynamic parts are called Values, State, Execution/Run,
and Objects.

When talking about code, the actual instructions are the static part, and
stored in memory (or disk). 

The actual execution of this code is the dynamic part and run by a processor
(or virtual runtime environment).

A dynamic part always presupposes a static part. You cannot understand a
VERB unless a NOUN is implied. One must study anatomy first before
physiology; numbers before functions; etc.

Programming languages, like mathematics, is a method for humans to transmit
these concepts and ideas to other humans via an alphabet or symbolic scheme.

Compilers transform programming languages into that which a computer can
understand. This is how computational science goes one step further than
mathematics.

All languages (programming, mathematical, and natural) must model both the
statics and the dynamics of their system when describing it.

Natural languages combine “nouns” and “verbs” to get sentences—their
smallest unit of information.

Programming languages combine “structures” and “code” to get functions. A
subroutine is a function with no return value.

Different naturally languages have different syntax. German ends sentences
with verbs. English puts them closer to the beginning.

Programming languages have similar analogies too.

“Structured programming languages” (Pascal, C, FORTRAN, LISP) begin with
functions that operate on specific structures (called parameters). They are
verb-oriented in nature.

“Object-oriented programming languages (Java, C#, CLOS) begin with
structures (called classes) that send messages to methods. They are
noun-oriented in nature.

In a structured programming language, I might write: FLIP(Pancake, Quickly)

In an object-oriented programming language, I would write
Pancake.FLIP(Quickly)

For an English analogy, we have an obvious noun (the subject) called
Pancake. There’s a verb: To Flip. We have parameters that we pass in to the
function call to modify its behavior. If the parameter is a constant, like
Quickly, we call it an adverb. If it is another object, we call it a direct
object, or indirect object, or prepositional object—depending on its English
use. Properties of an object are called adjectives.

When you see a declaration in code that looks like this (regardless of
whether it’s structured or OO): int i = 5 … to declare an integer called “i"
that contains the value 5, int is the class (or structure, or type) and i is
the object. 5 is the initial state of the object. If you want to convert
this number to a string in a structured programming language, you might
write this: ToString(i)

To do the same in an object-oriented language, you’d write i.ToString()

It’s all syntax! Just like there is nothing in English I can’t say in
German, there’s no system modeled in an object-oriented programming language
that I cannot express in a structured programming one. 

In case you read articles on the net, here are some vocabulary use cases:

*	“Classes” store the static non-changing parts of a system in memory
(or disk). Classes contain static structures (or types) called “fields” or
“attributes”, and static code called “methods”.
*	“Objects” are classes that are being run by the processor (or the
virtual runtime environment). Their fields (called “properties”) have actual
values (the dynamic parts). This is why we say that “objects have state”. 
*	The same class can be copied into memory multiple times (called
instances, or just objects) each being submitted to a processor and each
having different state. This is why we say that “objects have identity”.
*	Every method in a class operates on a specific object instance of
it. This is why we say that “objects have behavior”. When a “method” is
executed, it is called a “message”.
*	Static methods; dynamic messages. Static fields (or attributes);
dynamic properties. Static types (or schema); dynamic state.

To understand ABM’s, like understanding anything, I suggest this approach:
form a paradigm by understanding the static parts first, and then observe
(or deduce) the dynamics in the context of the statics.

The more chaotic, less rigorous approach, involves looking at all the
dynamics simultaneously (or participating in those existential terms) and
then trying to infer the structure.

I think this latter approach leads to confusion, frustration, and
post-modernistic dialogs. 

When the only way to understand the statics is by black-box observation of
the dynamics, then use the scientific principle: fix all but one dynamic,
and vary it in a controlled manner.

Robert Howard
Phoenix, Arizona

  _____  

From: friam-bounces at redfish.com [mailto:friam-bounces at redfish.com] On Behalf
Of Robert Holmes
Sent: Saturday, June 02, 2007 9:48 AM
To: The Friday Morning Applied Complexity Coffee Group
Subject: Re: [FRIAM] Fwd: ABM

Here's a couple of sites that could be worth checking out Phil:

http://www.google.com/search?hl=en
<http://www.google.com/search?hl=en&q=object+oriented+programming&btnG=Googl
e+Search> &q=object+oriented+programming&btnG=Google+Search
http://en.wikipedia.org/wiki/Object-oriented_programming 

Robert

On 6/2/07, Phil Henshaw < sy at synapse9.com <mailto:sy at synapse9.com> > wrote:

Well, for the knowledgeably ignorant among us... what the heck is 
'object oriented' programming anyway.  All the code looks like code to
me, and other than having a few more sub-routines I don't understand the
purpose or design of... what's changed other than standardizing a few 
protocols across platforms?

Phil Henshaw                       ¸¸¸¸.·´ ¯ `·.¸¸¸¸

============================================================

FRIAM Applied Complexity Group listserv

Meets Fridays 9a-11:30 at cafe at St. John's College

lectures, archives, unsubscribe, maps at http://www.friam.org

============================================================

FRIAM Applied Complexity Group listserv

Meets Fridays 9a-11:30 at cafe at St. John's College

lectures, archives, unsubscribe, maps at http://www.friam.org

Marko A. Rodriguez

Los Alamos National Laboratory (P362-proto)

Los Alamos, NM 87545

Phone +1 505 606 1691

http://www.soe.ucsc.edu/~okram

-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://redfish.com/pipermail/friam_redfish.com/attachments/20070603/680d94c9/attachment.html 