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 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.
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: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED]
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&q=object+oriented
+programming&btnG=Google+Search
http://en.wikipedia.org/wiki/Object-oriented_programming
Robert
On 6/2/07, Phil Henshaw < [EMAIL PROTECTED]> 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
============================================================
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