[FRIAM] Fwd: ABM (Object-Oriented)

[Robert Lancaster]

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: 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&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> 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

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