subject:"Re\: \[FRIAM\] Distributed Agents and Alan Kay's Universal Interface Language"


Saul Caganoff wrote:

and here's a couple more ideas:

http://www.google.com/search?q=distributed+computing+javascript+browser 

To take a significant amount of CPU time from a user, especially in the 
background, it will be necessary to ask for opt-in.   Publishing 
JavaScript to run as a side effect of various web pages probably won't 
please some people too much, especially if it is a project they don't 
care about or even dislike.. say, computing prime numbers for Allah... 
when the website was apparently a dating site. 

If there was a clear indication on the page on why and how to enable it, 
and the calculation was somehow aligned with the page, then that maybe 
it would catch on..  People would browse on and off different pages, so 
of course the calculations (or agents) would need to be able to migrate 
quickly and/or be small.   Advantage of just installing an app based on 
something like BOINC would be that computations could be longer-lived.


Marcus


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Saul Caganoff

and here's a couple more ideas:
http://www.google.com/search?q=distributed+computing+javascript+browser



2009/5/26 Marcus G. Daniels 

> Stephen Guerin wrote:
>
>> 4) What is the compute infrastructure?
>>>
>>
>> Existing web/ftp servers, browsers and applications running on client
>> machines.
>>
> 2 ideas:
>
> http://boinc.berkeley.edu/ http://www.playstation.com/life/en/aboutch.html
>
>
> 
> 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
>



-- 
Saul Caganoff
Enterprise IT Architect
LinkedIn: http://www.linkedin.com/in/scaganoff

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Alice (aka Tory) -

Thus finally proving the existence of parallel worlds.
Now if we could just find the wormhole...

I believe you found one when you joined this list, though it might be 
somewhat more of a Rabbit Hole?


- Mad Hatter

P.S. does that make Doug the Red Queen and Stephen the White Rabbit?  
And who precisely is the Hookah Smoking Catterpillar?

P.P.S.  Everyone, back to our game of FriamCroquet!


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Stephen Guerin wrote:

4) What is the compute infrastructure?


Existing web/ftp servers, browsers and applications running on client 
machines. 

2 ideas:

http://boinc.berkeley.edu/ 
http://www.playstation.com/life/en/aboutch.html



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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Stephen Guerin



On May 25, 2009, at 5:56 PM, Douglas Roberts wrote:
Ok, so now that we have our trip down OOP Memory Land out of the  
way, a few questions:

1) What are the agents in this > 1.0E^6 agent simulation?


We're not designing a simulation. We're trying to architect for a  
distributed agent-oriented application development environment.



2) What are the rules that define how they interact?

Most rules will be application specific.



3) What are the communications requirements between agents?

application-specific



4) What is the compute infrastructure?
Existing web/ftp servers, browsers and applications running on client  
machines.




5) What are the desired results from running the ABM?

Not an ABM. It will be an application platform. same as #1.



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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Victoria Hughes


Thus finally proving the existence of parallel worlds.
Now if we could just find the wormhole...



On May 25, 2009, at 7:21 PM, Gary Schiltz wrote:

In addition, a real world application is one that the client can't  
adequately describe, but which needs to be done in half the time and  
with half the money required to build it. Oh, and of course it needs  
to run twice as fast as is theoretically possible. In other words, a  
real world application is one that can be built in some other real  
world.


;; Gary


Carl Tollander wrote:
So a 'real world' application is one you never quite have enough  
memory and power for?



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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Gary Schiltz

In addition, a real world application is one that the client can't  
adequately describe, but which needs to be done in half the time and  
with half the money required to build it. Oh, and of course it needs  
to run twice as fast as is theoretically possible. In other words, a  
real world application is one that can be built in some other real  
world.


;; Gary


Carl Tollander wrote:
So a 'real world' application is one you never quite have enough  
memory and power for?



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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Carl Tollander wrote:
So a 'real world' application is one you never quite have enough 
memory and power for?
THAT has been my experience categorically. 


Well said.


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Doug -



Isn't this fun?  We could probably go on like this this all day!
I was never a Boy Scout, but from what I remember anecdotally, once one 
has their merit badge, it cannot be taken away (though they can be 
stolen and clandestinely resewn onto ones own sash)... 

Yet I think there are old Eagle Scouts out there arguing the merits of 
flint-and-steel over bow-and-stick or the Bowline vs the Half-Hitch or 
Short-Sheeting vs the Hand-in-Warm-Water-at-Night trick.


Surreal-ly yours,
- the Big Guy




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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

OK... It is all I can do to avoid a segue into Soylent Green analogies... 


- SS



But yes, given the other meaning of execution, I agree with you with 
respect to how to probably handle the death and garbage collection. I 
suspect we might adopt more of an cellular apotosis model 
 where 
agents remove themselves unless they constantly receieve a 
keep-alive-message from other agents. There's also the idea that there 
should be a mechanism where agents will migrate away from the edge of 
the network where users are to lower cost, high latency parts of the 
network when they are less in demand - a kind of cold storage.


-S





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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

Ok, so now that we have our trip down OOP Memory Land out of the way, a few
questions:

1) What are the agents in this > 1.0E^6 agent simulation?
2) What are the rules that define how they interact?
3) What are the communications requirements between agents?
4) What is the compute infrastructure?
5) What are the desired results from running the ABM?

--Doug

On Sun, May 24, 2009 at 2:01 PM, Stephen Guerin
wrote:

> So a few of us are exploring new ways of constructing scalable distributed
> agent systems and are playing around with architecting a first instantiation
> in either Javascript or in Smalltalk. We are interested in architecting a
> system that grow and evolve without collapsing on the weight of itself, much
> in the same way the Internet has been able to grow over the last 40 years
> without a reboot.
>
> Relatedly, I was watching Alan Kay's'97 OOPSLA address <
> http://video.google.com/videoplay?docid=-2950949730059754521>, and his
> call for a Universal Interface Language popped out at me and I looked around
> for potential implementations since then. Wikipedia claims there hasn't been
> one yet:
>  
>
> I was wondering if folks know of any candidates for a Universal Interface
> Language that wikipedia authors may have missed.
>
> And, if we were to make our own, should we start with a REST-like protocol
> 
> supplemented by server-side javascript or other such animal?
>
> -Steve
>
> --- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
> stephen.gue...@redfish.com
> (m) 505.577.5828  (o) 505.995.0206
> redfish.com _ sfcomplex.org _ simtable.com_ lava3d.com
>
>
>
>
>

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

On Mon, May 25, 2009 at 3:06 PM, Carl Tollander  wrote:

> So a 'real world' application is one you never quite have enough memory and
> power for?
>
>
Yeah, pretty much.

First you build a model that approximates the system you want to model.

Then you realize that there are features that would be *really nice* for it
to have.  So you add them in.

Then, someone come along and says, "Gee, that's nice.  But I would really
like for it to do X, Y, and Z, instead."

So you wedge that in.

Then, it doesn't run fast enough.

Then it runs out of memory.

Then, you design version 2 to address the performance shortcomings.

Repeat cycle as required until your funding agency finds a new contractor.

--Doug
-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Carl Tollander

So a 'real world' application is one you never quite have enough memory 
and power for?


Douglas Roberts wrote:
I believe that under optimal conditions (from the perspective of the 
garbage collecting language) a benchmark can be contrived that equals 
malloc.  I also believe that the converse is true, especially for 
large applications.  I cannot count the times I have had to reboot a 
LISP machine or kill a Java app because they had ground themselves 
into the ground attempting a GC.


I suspect, without offering any evidence to support my suspicions that 
most "real world" applications, i.e. large to the bursting point of 
the hosts' memory and processing power, will favor malloc over GC.


--Doug

On Mon, May 25, 2009 at 11:04 AM, Marcus G. Daniels 
mailto:mar...@snoutfarm.com>> wrote:


Stephen Guerin wrote:

Ah, by control over its own execution, I meant "execution" as
thread of computation.

Yeah, I realize the word was overloaded..  See my other e-mail on
not being able to predictably get resources.  (Scheduling a thread
is does not imply actually commencing execution.)

Here I was just getting Doug to confront his prejudice about
garbage collectors.  ;-)

I suspect we might adopt more of an cellular apotosis model

where agents remove themselves unless they constantly receieve
a keep-alive-message from other agents. There's also the idea
that there should be a mechanism where agents will migrate
away from the edge of the network where users are to lower
cost, high latency parts of the network when they are less in
demand - a kind of cold storage.

Cool.  I think biological approaches to resilience and system
optimization are intriguing..

Marcus



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




--
Doug Roberts
drobe...@rti.org 
d...@parrot-farm.net 
505-455-7333 - Office
505-670-8195 - Cell



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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

On Mon, May 25, 2009 at 11:52 AM, Marcus G. Daniels wrote:

>
> A person prototyping code for a new problem doesn't yet have whole thing in
> their head, so they don't want to commit to decisions like global sharing of
> data.  malloc/free is undesirable in that situation because it just adds one
> more thing to keep track of.

Well, yes, except...  Running your C++ prototype code through ValGrind and
checking for leaks is only one short step, and a good idea anyhow.  I've not
found keeping track of new()/delete() to be that onerous when prototyping.
On the other hand, having the crutch of a garbage collector always around
can cause a developer to become insensitive to memory issues...

Isn't this fun?  We could probably go on like this this all day!

;-}

>
>
> Marcus
>

--Doug

-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Douglas Roberts wrote:
I believe that under optimal conditions (from the perspective of the 
garbage collecting language) a benchmark can be contrived that equals 
malloc.
If a person can plan out a workset that is minimal and needed all of the 
time, then it won't need to be moved around independent of whether 
malloc or GC is used.   It can just be declared in fixed array on the 
heap and that is that.  Typically people that care about fast code plan 
out the use of memory in a careful way, and also use a language that 
generates code they can inspect and understand the generated machine 
language to be efficient.  That's typically C or C++ or Fortran.


A person prototyping code for a new problem doesn't yet have whole thing 
in their head, so they don't want to commit to decisions like global 
sharing of data.  malloc/free is undesirable in that situation because 
it just adds one more thing to keep track of.


Once they do have the whole problem understood (with the help of some 
exploratory programming), there's nothing stopping them from making a 
new production code that is fast.   This has nothing to do with GC vs. 
malloc though.   It's just a question of whether it is cheaper to throw 
more computers at it than it is to do some factoring and profiling or do 
a new implementation. 

There surely a class of problems where an implementation plan is evident 
before any code is written and there's a clear lifetime for certain 
blocks of data.   This would be a case where malloc/free would probably 
win.  I'd also expect it has a substantial overlap with the class of 
Boring Problems.


Marcus


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

I believe that under optimal conditions (from the perspective of the garbage
collecting language) a benchmark can be contrived that equals malloc.  I
also believe that the converse is true, especially for large applications.
I cannot count the times I have had to reboot a LISP machine or kill a Java
app because they had ground themselves into the ground attempting a GC.

I suspect, without offering any evidence to support my suspicions that most
"real world" applications, i.e. large to the bursting point of the hosts'
memory and processing power, will favor malloc over GC.

--Doug

On Mon, May 25, 2009 at 11:04 AM, Marcus G. Daniels wrote:

> Stephen Guerin wrote:
>
>> Ah, by control over its own execution, I meant "execution" as thread of
>> computation.
>>
> Yeah, I realize the word was overloaded..  See my other e-mail on not being
> able to predictably get resources.  (Scheduling a thread is does not imply
> actually commencing execution.)
>
> Here I was just getting Doug to confront his prejudice about garbage
> collectors.  ;-)
>
>> I suspect we might adopt more of an cellular apotosis model <
>> http://evolutionofcomputing.org/Multicellular/Apoptosis.html> where
>> agents remove themselves unless they constantly receieve a
>> keep-alive-message from other agents. There's also the idea that there
>> should be a mechanism where agents will migrate away from the edge of the
>> network where users are to lower cost, high latency parts of the network
>> when they are less in demand - a kind of cold storage.
>>
> Cool.  I think biological approaches to resilience and system optimization
> are intriguing..
>
> Marcus
>
>
> 
> 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
>

-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Stephen Guerin wrote:
Ah, by control over its own execution, I meant "execution" as thread 
of computation.
Yeah, I realize the word was overloaded..  See my other e-mail on not 
being able to predictably get resources.  (Scheduling a thread is does 
not imply actually commencing execution.)


Here I was just getting Doug to confront his prejudice about garbage 
collectors.  ;-)
I suspect we might adopt more of an cellular apotosis model 
 where 
agents remove themselves unless they constantly receieve a 
keep-alive-message from other agents. There's also the idea that there 
should be a mechanism where agents will migrate away from the edge of 
the network where users are to lower cost, high latency parts of the 
network when they are less in demand - a kind of cold storage.
Cool.  I think biological approaches to resilience and system 
optimization are intriguing..


Marcus


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Douglas Roberts wrote:
I do feel compelled to point out that garbage collectors are extremely 
heavy weight language components, and are one of the features of Java 
that prevent it from competing with C++ for large-scale computational 
efficiency.
You can believe what you want, but see figures 4, 5, 6 of the URL below 
for a conservative garbage collector outperforming malloc in C.  Even in 
benchmarks where malloc is faster, it's within a factor of two.


http://www.hpl.hp.com/techreports/2000/HPL-2000-165.html

Similar results 15 years ago:

ftp://ftp.cs.colorado.edu/pub/techreports/zorn/CU-CS-665-93.ps.Z




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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Owen Densmore

I actually had a fairly long talk with Bjarne Stroustrup while  
building an UI Toolkit out of (would you believe) PostScript for the  
NeWS (Network Extensible Window System).  We had realized that PS  
really was, like Javascript, a very lisp-like language and so  
prototyped (pun intended for you JS'ers) a 1-page of code classing  
system, with multiple inheritance and mix-ins if needed.

This was in the mid-80s.

Bjarne was *really* clear that C++ was *not* supposed to be an OO  
version of C.  But a *better* C.

The PS-JS link is quite strong, historically, BTW.  Both are attached  
to a widely distributed visual programming system (Printers,  
Browsers).  Both are dynamic, scripting, and ubiquitous.  Both are  
standardized.  Etc.

-- Owen

On May 25, 2009, at 8:01 AM, Prof David West wrote:

 Doug,

Some short answers, we can discuss further some time if interested.
First:  the "technical" reasons C++ was not considered OO = strong  
typing, friend declarations, multiple inheritance, explicit  
constructors, and an over-dependence on function overrides.

Second: subtler, but in my opinion more important, the philosophy of  
the language - C++ was never intended to be an OO language.   
Marketing saw some superficial similarities and jumped on the OO  
bandwagon and represented the language as something it was not  
intended to be. (They also worked very hard to redefine OO to be  
closer to what C++ offered - their own version of Newspeak.)

C++ was intended to be a means to impose structured programming  
discipline on C programmers without, in any way, interfering with  
the hyper-efficient performance characteristics that arose from  
being as faithful a representation of the hardware as possible.

In contrast - the OO tradition that began with Simula (not Simula I  
which was already moving away from the philosophical ideal) and was  
embodied in Self and Smalltalk, did not care about the machine, did  
not care about efficiency, it was all about the domain - faithful  
representation of same - and about human-machine "natural"  
communication about that shared domain (both humans and objects  
"lived" in the same "world").

C++ versus Smalltalk was an expression of an even deeper  
philosophical divide between formalists and aformalists that traces  
back to the ascendency of the former during the Age of Reason.

dave

On Sun, 24 May 2009 18:35 -0600, "Douglas Roberts" > wrote:

Not to digress, but Dave kind of lost me one day at a FRIAM when he  
said "C++ is not object oriented."  I didn't really know what he  
meant, because I've been using C++ for about 20 years now to  
accomplish polymorphism via object inheritance, containment, and  
method specialization (with and without templates) -- which use  
pretty much meets most definitions of OO programming that I've  
encountered.

Dave, I'd be interested in knowing what you meant...

--Doug

On Sun, May 24, 2009 at 6:20 PM, Stephen Guerin > wrote:
On Sun, May 24, 2009 at 5:47 PM, Douglas Roberts > wrote:
> Interesting.  Other issues that will come to play with an ABM of  
the
> intended scales you describe are synchronization of the various  
asynchronous
> distributed components, message passing latency, and message  
passing
> bandwidth.  Hopefully a course-grained sync & message passing  
design can be
> developed, because http is not good for either latency or  
bandwidth (using

> Myrinet or Infiniband for comparison).
Yeah, I'm not thinking this would be used for a single large-scale  
ABM

for exactly the synch issues you describe.

This would be more for authoring and deploying many smaller-scale
applications written with an agent-oriented perspective. What Dave
West talks about when he refers to how object-orientation was
originally conceived not how current object-oriented programming is
done. This is close to what Smalltalk/Seaside looks like but probably
implemented within Javascript.

-S
--

--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
stephen.gue...@redfish.com
(m) 505.577.5828  (o) 505.995.0206
redfish.com _ simtable.com _ sfcomplex.org _ lava3d.com

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

--
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Stephen Guerin

On May 24, 2009, at 10:05 PM, Marcus G. Daniels wrote:

Steve wrote:
To better describe agent-oriented, I would like to extend an
object to:
1)
2)
3) have control over its own execution
4)
5)

Typically garbage collectors observe for objects that are isolated
from all others, and then call finalization routines on their behalf
(like executors of a will). But for agent simulations, I think it
would be useful to have voluntary and involuntary kill capability
integrated in the collector whereby all references to that object
would be nulled and the finalization process run.Assisted
suicide would be the voluntary form, presumably limited by rules
that examine of various properties of the object and connected
objects.
The unique applicability to ABM is that engineered programs have
objects in different roles for reasons, and it would break the whole
thing to have the program act on itself that way. On the other
hand, ABMs are looser collections of more autonomous objects where
agents come and go, and the proper analogy is more often killing or
resource depletion, rather voluntary self-removal (e.g. digging your
own grave via a `destructor').

Ah, by control over its own execution, I meant "execution" as thread
of computation.

But yes, given the other meaning of execution, I agree with you with
respect to how to probably handle the death and garbage collection. I
suspect we might adopt more of an cellular apotosis model where agents remove themselves unless they constantly receieve a
keep-alive-message from other agents. There's also the idea that there
should be a mechanism where agents will migrate away from the edge of
the network where users are to lower cost, high latency parts of the
network when they are less in demand - a kind of cold storage.

-S

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

I don't disagree with any of that, Marcus.  I do feel compelled to point out
that garbage collectors are extremely heavy weight language components, and
are one of the features of Java that prevent it from competing with C++ for
large-scale computational efficiency.

--Doug

On Mon, May 25, 2009 at 10:11 AM, Marcus G. Daniels wrote:

> Douglas Roberts wrote:
>
>> To some, I suppose lack of efficiency and the ability to implement pure,
>> faithful representations of the physical system being modeled are positive
>> attributes of a language.
>> Therefore, 100% faithfulness of representation of the physical system is
>> not only not needed, it can get in the way of producing results.
>>
>>  There's faithful in the sense of simulating things that aren't relevant
> to a model, and then there's faithful in the sense of thinking things
> through.   Doing the latter needn't get in the way of efficiency, it can
> actually facilitate it.  In the assisted suicide example, a garbage
> collector is in the best position to determine who has references to an
> object that is being removed.  Without that support, ad-hoc mechanisms to
> overwrite dead objects with death signatures would be needed (while keeping
> enough of its memory around for the signature pattern), otherwise there'd be
> invalid pointers in the simulation after the object was deallocated.
>
> IMO, research often does get in the way of  production work, and vice
> versa.
>
> Marcus
>
>
> 
> 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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Douglas Roberts wrote:
To some, I suppose lack of efficiency and the ability to implement 
pure, faithful representations of the physical system being modeled 
are positive attributes of a language.
Therefore, 100% faithfulness of representation of the physical system 
is not only not needed, it can get in the way of producing results.


There's faithful in the sense of simulating things that aren't relevant 
to a model, and then there's faithful in the sense of thinking things 
through.   Doing the latter needn't get in the way of efficiency, it can 
actually facilitate it.  In the assisted suicide example, a garbage 
collector is in the best position to determine who has references to an 
object that is being removed.  Without that support, ad-hoc mechanisms 
to overwrite dead objects with death signatures would be needed (while 
keeping enough of its memory around for the signature pattern), 
otherwise there'd be invalid pointers in the simulation after the object 
was deallocated.


IMO, research often does get in the way of  production work, and vice 
versa.


Marcus


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

That's what we keep you around for, big guy!

Cheers, yourself.

--Doug

On Mon, May 25, 2009 at 10:06 AM, Steve Smith  wrote:

>
>
> Neither has been the usual raving fanatic I am used to,
> - Steve
>
>

-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language





Doug/Dave/innocent bystanders -

Actually, this exchange is more useful to me than most I've seen on
this topic.   

As usual, I understand both sides of the argument and agree with
neither!

Or to be contrary, I agree with both.   I appreciate the elegance of
representation that well-designed notations offer, especially in domain
specific problems.   I also appreciate the value of efficiency and that
the *real* customer should never see the code and should only see the
interface and its performance (qualitative and quantitative).  

On the other (other) hand, it seems that an important customer of our
code is always also ourselves and our peers.  Even though we never
re-use or share code as much as we should, we *do* re-use and share
code and people *do* inherit eachothers' code for continuation,
propagation, remediation, etc.   I find it irritating and inconvenient
when either extreme is obtained.  

When I must learn (and sometimes master) a relatively obscure (Simula,
Smalltalk, LISP, ObjC in that order) language because someone else
declared it to be the pinnacle of form and style.  Similarly, when
someone builds extravagant and convoluted abstractions in a language
never intended for it.  For example, when someone tries to implement
the functionality of Snobol or LISP in C.   These are the times when a
less "elegant" or elaborate abstraction is better.  While it might seem
mundane, a good deal of very simple string manipulation and/or logic
implementation has been done in C or Fortran quite well in simple
ways.   I am glad to be free of the restrictions (esp. of Fortran IV)
of a simple procedural language with limited and limiting structures,
but often find that the modes of use of more expressive languages to be
?deliberately? obtuse?

Do we, as prideful practitioners, too often indulge in our egos by
raising elegance (or efficiency) above its station, or for sure utility
and relevance?   I do not want to take away from either end of the
spectrum, those who pursue (perhaps Dave fits this) purity and elegance
for it's own sake, nor from those who pursue (I think this shoe fits
Doug's foot) efficiency and economy as an art-form of it's own.  
People on top of their game (either game) can do this with little or no
loss of final utility.   But it is those of us (I appreciate both but
aspire to neither) who muddle along in our many ways, often get caught
in the crossfire of a holy war between the Big Enders and the Little
Enders?

The lucidity of both Doug and Dave in this discussion has been very
useful.  Neither has been the usual raving fanatic I am used to,
perhaps this is a testimony to these individuals, to a maturing field,
or to this forum.  Perhaps all three.

Carry on!

- Steve

  
  


 
In contrast - the OO tradition that began with Simula (not
Simula I which was already moving away from the philosophical ideal)
and was embodied in Self and Smalltalk, did not care about the machine,
did not care about efficiency, it was all about the domain - faithful
representation of same - and about human-machine "natural"
communication about that shared domain (both humans and objects "lived"
in the same "world").
 


  
  
To some, I suppose lack of efficiency and the ability to implement
pure, faithful representations of the physical system being modeled are
positive attributes of a language.  One the other hand, in practical
use simulations are only required to represent the physical system of
interest at some level of abstraction which has been identified as
sufficient to answer the questions being asked of the system.
Therefore, 100% faithfulness of representation of the physical system
is not only not needed, it can get in the way of producing results.
  
As to efficiency, what can I say: efficiency is everything to the
analyst.  Without it even the most beautiful, elegant model won't be
used, because results that are produced too late, or which require too
much effort to produce are simply of little use.
  
IMO, the most important aspect of developing useful simulations is not
the elegance of the language being used, but rather the skills of the
model designer in producing a design that is properly abstracted: not
too much detail, not too little, which will address the pertinent
analysis issues.  The "pureness" of the OO language being used really
doesn't come to play with any of the actual fielded applications I've
been involved with.
  
  






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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language


Douglas Roberts wrote:

A snark sash can *never* be too heavy!

Snarf!


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

A snark sash can *never* be too heavy!

;-}



> Do I still get to keep my OO Merit Badge?
>
> sure, but more to the point, you get another gold star added to your
> glibness sash... isn't that thing getting kinda heavy?
>
> nicely done.
>
>

-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

Hey, thanks Dave.

A couple of comments:



> In contrast - the OO tradition that began with Simula (not Simula I which
> was already moving away from the philosophical ideal) and was embodied in
> Self and Smalltalk, did not care about the machine, did not care about
> efficiency, it was all about the domain - faithful representation of same -
> and about human-machine "natural" communication about that shared domain
> (both humans and objects "lived" in the same "world").
>
>

To some, I suppose lack of efficiency and the ability to implement pure,
faithful representations of the physical system being modeled are positive
attributes of a language.  One the other hand, in practical use simulations
are only required to represent the physical system of interest at some level
of abstraction which has been identified as sufficient to answer the
questions being asked of the system. Therefore, 100% faithfulness of
representation of the physical system is not only not needed, it can get in
the way of producing results.

As to efficiency, what can I say: efficiency is everything to the analyst.
Without it even the most beautiful, elegant model won't be used, because
results that are produced too late, or which require too much effort to
produce are simply of little use.

IMO, the most important aspect of developing useful simulations is not the
elegance of the language being used, but rather the skills of the model
designer in producing a design that is properly abstracted: not too much
detail, not too little, which will address the pertinent analysis issues.
The "pureness" of the OO language being used really doesn't come to play
with any of the actual fielded applications I've been involved with.

Cheers,

--Doug

-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language





Dave -

Well stated.   

I've never been in the middle of this fray but all around it, and I
have to say that I'm always puzzled by it.

By the time Objective C came along I was ready for a "practical"
object-oriented language.  I jumped on the bandwagon and was hugely
disappointed.   I was disappointed by two things:  That OO didn't live
up to my expectations; That C++ rose up like a tide and washed ObjC out
of the game for the most part.

My own experience was that I was already an experienced enough
programmer that most of what ObjC or C++ gave me, I had already learned
to handle with raw C.  The explicitness of "objects" rather than
careful and clever use of structures and functions was a boon, but not
a huge one.  I had never learned Simula or Smalltalk but had sampled
many other languages (APL, Prolog, and Snobol being some of my
favorites for specific problem domains).  While I had a degree in
Mathematics rather than Computer Science, most of the abstract
arguements about the value of "pure OO" have never moved me very
much.   

As a pragmatist (completely different kind of pragmatist than Doug
though ) and a happy customer of Java, C++, and ObjC (thank
you Steve Jobs), I still find the brouhaha over the differences
distracting.   I am happy to give over to the purists that C++ is a
weak sister to "real" OO, but having never really felt that "real" or
"forged" OO was as big of a revolution as often implied, I'm not that
motivated by it.  I'm glad to have it, but find it somewhat overrated.

I realize I am a dinosaur in many ways.  I can see how those who cut
their teeth on various OO tools (authentic and/or forged) might find
this a lot more personal, but I also know that many on this list have
as much (or more) grey in their beards as I do.  

As I shared with Guerin in a private conversation...   OO fell short of
my expectations of what "Objects" should be.  Composable Simulations
and Agent Based Modeling provided a little of that back, but in turn,
Agent Modeling fell far short of what I expected from "Agents".

Without needing to disparage either OO or ABM as it is practiced, I see
there is great utility in both, I am left to wonder if Computer Science
is not hugely irresponsible in using up the best ideas/terms on fairly
weak, early examples of what they are pursuing?  In my own field, I
find that we "claimed" Virtual Reality at least 20 years too early,
probably more.   

Just to add a little more to my morning rant, I have to take a potshot
at "Design Patterns" as well.  I was a deep fan of Christopher
Alexander long before the Gang of Four wrote "Design Patterns".  I
thought it insightful and clever that they discovered/recognized
Alexander and did a fair job of applying his ideas to programming, but
their book, the movement that went with it, etc. missed *so much* of
Alexander's ideas that I was crestfallen.  

Is anybody else out there as disappointed as I with our propensity for
claiming territory gained long before anything significant was actually
gained?   

-  Steve
PS.  Guerin - See what you started?


  
  
  
   Doug,
   
  Some short answers, we can discuss further some time if
interested.
  First:  the "technical" reasons C++ was not considered OO =
strong typing, friend declarations, multiple inheritance, explicit
constructors, and an over-dependence on function overrides.
   
  Second: subtler, but in my opinion more important, the
philosophy of the language - C++ was never intended to be an OO
language.  Marketing saw some superficial similarities and jumped on
the OO bandwagon and represented the language as something it was not
intended to be. (They also worked very hard to redefine OO to be closer
to what C++ offered - their own version of Newspeak.)
   
  C++ was intended to be a means to impose structured programming
discipline on C programmers without, in any way, interfering with the
hyper-efficient performance characteristics that arose from being as
faithful a representation of the hardware as possible.
   
  In contrast - the OO tradition that began with Simula (not
Simula I which was already moving away from the philosophical ideal)
and was embodied in Self and Smalltalk, did not care about the machine,
did not care about efficiency, it was all about the domain - faithful
representation of same - and about human-machine "natural"
communication about that shared domain (both humans and objects "lived"
in the same "world").
   
  C++ versus Smalltalk was an _expression_ of an even deeper
philosophical divide between formalists and aformalists that traces
back to the ascendency of the former during the Age of Reason.
   
  






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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Prof David West

 Doug,

Some short answers, we can discuss further some time if
interested.
First:  the "technical" reasons C++ was not considered OO =
strong typing, friend declarations, multiple inheritance,
explicit constructors, and an over-dependence on function
overrides.

Second: subtler, but in my opinion more important, the philosophy
of the language - C++ was never intended to be an OO language.
Marketing saw some superficial similarities and jumped on the OO
bandwagon and represented the language as something it was not
intended to be. (They also worked very hard to redefine OO to be
closer to what C++ offered - their own version of Newspeak.)

C++ was intended to be a means to impose structured programming
discipline on C programmers without, in any way, interfering with
the hyper-efficient performance characteristics that arose from
being as faithful a representation of the hardware as possible.

In contrast - the OO tradition that began with Simula (not Simula
I which was already moving away from the philosophical ideal) and
was embodied in Self and Smalltalk, did not care about the
machine, did not care about efficiency, it was all about the
domain - faithful representation of same - and about
human-machine "natural" communication about that shared domain
(both humans and objects "lived" in the same "world").

C++ versus Smalltalk was an expression of an even deeper
philosophical divide between formalists and aformalists that
traces back to the ascendency of the former during the Age of
Reason.

dave

On Sun, 24 May 2009 18:35 -0600, "Douglas Roberts"
 wrote:

  Not to digress, but Dave kind of lost me one day at a FRIAM
  when he said "C++ is not object oriented."  I didn't really
  know what he meant, because I've been using C++ for about 20
  years now to accomplish polymorphism via object inheritance,
  containment, and method specialization (with and without
  templates) -- which use pretty much meets most definitions of
  OO programming that I've encountered.
  Dave, I'd be interested in knowing what you meant...
  --Doug

On Sun, May 24, 2009 at 6:20 PM, Stephen Guerin
<[1]stephen.gue...@redfish.com> wrote:

On Sun, May 24, 2009 at 5:47 PM, Douglas Roberts
<[2]d...@parrot-farm.net> wrote:
> Interesting.  Other issues that will come to play with an ABM
of the
> intended scales you describe are synchronization of the various
asynchronous
> distributed components, message passing latency, and message
passing
> bandwidth.  Hopefully a course-grained sync & message passing
design can be
> developed, because http is not good for either latency or
bandwidth (using
> Myrinet or Infiniband for comparison).

  Yeah, I'm not thinking this would be used for a single
  large-scale ABM
  for exactly the synch issues you describe.
  This would be more for authoring and deploying many
  smaller-scale
  applications written with an agent-oriented perspective. What
  Dave
  West talks about when he refers to how object-orientation was
  originally conceived not how current object-oriented
  programming is
  done. This is close to what Smalltalk/Seaside looks like but
  probably
  implemented within Javascript.

-S
--
--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
[3]stephen.gue...@redfish.com
(m) 505.577.5828  (o) 505.995.0206

  [4]redfish.com _ [5]simtable.com _ [6]sfcomplex.org _
  [7]lava3d.com

FRIAM Applied Complexity Group listserv
Meets Fridays 9a-11:30 at cafe at St. John's College
lectures, archives, unsubscribe, maps at [8]http://www.friam.org

  --
  Doug Roberts
  [9]drobe...@rti.org
  [10]d...@parrot-farm.net
  505-455-7333 - Office
  505-670-8195 - Cell

References

1. mailto:stephen.gue...@redfish.com
2. mailto:d...@parrot-farm.net
3. mailto:stephen.gue...@redfish.com
4. http://redfish.com/
5. http://simtable.com/
6. http://sfcomplex.org/
7. http://lava3d.com/
8. http://www.friam.org/
9. mailto:drobe...@rti.org
  10. mailto:d...@parrot-farm.net

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-25 Thread Stephen Guerin


Robert being dangerously inquisitive

Coincidence? Or perhaps Stephen has some some sinister motive


it's all coming together -- Just a few more CPUs and the plot will be  
ready.  muahaa haaa ... :-)




I'm curious what you are trying to model that requires 10^15 agents.


We're not trying to write a large single agent-based model. We're  
looking for an distributed agent architecture on which to write web- 
based applications.


-S



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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Robert Holmes

I'm curious what you are trying to model that requires 10^15 agents. I just
typed this number into WolframAlpha and got:


~~ 50 x the number of red blood cells in the human body (~~ 2x10^13)


... in other words the number of red blood cells in the FRIAM mailing list
(give or take).

Coincidence? Or perhaps Stephen has some some sinister motive

-- Robert

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Steve Smith





Douglas Roberts wrote:
Oregon just passed an assisted suicide law...


  
  
To better describe agent-oriented, I would like to extend an object to:
  
  



  
   3)
have control over its own execution
  
  
Do I still get to keep my OO Merit Badge? 
  
  

sure, but more to the point, you get another gold star added to your
glibness sash... isn't that thing getting kinda heavy?

nicely done.





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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Marcus G. Daniels


Stephen Guerin wrote:

 3) have control over its own execution


Because resources are finite, an object can only seek resources, e.g. 
through scheduling protocols for a resource or through growth and 
reproduction.  Agents don't have free will any more than we do.  :-)



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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Marcus G. Daniels


Douglas Roberts wrote:

Oregon just passed an assisted suicide law...


To better describe agent-oriented, I would like to extend an
object to:
 1)
 2) 


 3) have control over its own execution
 4)
 5)

Typically garbage collectors observe for objects that are isolated from 
all others, and then call finalization routines on their behalf (like 
executors of a will).   But for agent simulations, I think it would be 
useful to have voluntary and involuntary kill capability integrated in 
the collector whereby all references to that object would be nulled and 
the finalization process run.Assisted suicide would be the voluntary 
form, presumably limited by rules that examine of various properties of 
the object and connected objects. 

The unique applicability to ABM is that engineered programs have objects 
in different roles for reasons, and it would break the whole thing to 
have the program act on itself that way.   On the other hand, ABMs are 
looser collections of more autonomous objects where agents come and go, 
and the proper analogy is more often killing or resource depletion, 
rather voluntary self-removal (e.g. digging your own grave via a 
`destructor'). 


Marcus


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

Oregon just passed an assisted suicide law...


> To better describe agent-oriented, I would like to extend an object to:
>  1)
>  2)

 3) have control over its own execution
>  4)
>  5)
>
>
Do I still get to keep my OO Merit Badge?

-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Marcus G. Daniels


russell standish wrote:

By comparison, doing MPI programming using a simple class reflection
library is total dream. 
Can do whole thing (generating MPI serialization code) at compile time, 
without any markup, even with plain C:


https://developer.mozilla.org/en/Dehydra


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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Stephen Guerin

When I wrote:
> This would be more for authoring and deploying many smaller-scale
> applications written with an agent-oriented perspective. What Dave
> West talks about when he refers to how object-orientation was
> originally conceived not how current object-oriented programming is
> done. This is close to what Smalltalk/Seaside looks like but probably
> implemented within Javascript.

Doug responded:
Not to digress, but Dave kind of lost me one day at a FRIAM when he  
said "C++ is not object oriented."  I didn't really know what he  
meant, because I've been using C++ for about 20 years now to  
accomplish polymorphism via object inheritance, containment, and  
method specialization (with and without templates) -- which use  
pretty much meets most definitions of OO programming that I've  
encountered.

I was trying to express a move toward more agent-oriented  
architectures. I mentioned the Alan Kay conception of OOP trying to  
clarify what I meant by agent-oriented. I didn't intend to flame start  
a discussion on the OOP'ness of C++. Your OOP merit badges will not be  
revoked :-)

To better describe agent-oriented, I would like to extend an object to:
 1) be goal directed
 2) to lookup and message other agents
 3) have control over its own execution
 4) be able to persist itself (through serialization or database)
 5) be able to express itself through various UIs (toString,  
to3DObject, toHTML, toXML, etc)

Certainly this could be implemented in C++, Javascript, Smalltalk, and  
many other languages.

My interest in Javascript is the practicality of its deployability and  
that it comes with the nice bonuses (to me) of dynamic typing,  
functional programming and class-less objects that might let us  
develop, modify and deploy applications on the fly with no compile and  
restart process.

-S
--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
stephen.gue...@redfish.com
(m) 505.577.5828  (o) 505.995.0206
redfish.com _ sfcomplex.org _ simtable.com _ lava3d.com

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread russell standish

What I mean by pure OO C++ is full blown patterns implemented using
dynamic polymorphism etc, etc. You go through about 3 or 4 layers of
indirection via abstract classes to go from caller to callee. You need
6-8 windows open on the screen just to understand what some bit of
code is doing. And yes, its even worse when it's asyncronous threaded
code (which I've had to do my share of).

By comparison, doing MPI programming using a simple class reflection
library is total dream. And that's even without the sophistication of
using TotalView. See some of my papers on ClassdescMP.

My point wasn't that OO isn't useful or has its place. It is
definitely an important technique. Just that when overused, it
actually adds to the complexity of the solution. 

Cheers

On Sun, May 24, 2009 at 07:42:34PM -0600, Douglas Roberts wrote:
> Interesting that you'd say OO C++ is hard to debug.  With the proper tools,
> I've found it as easy as, well, interpreted LISP.  Now distributed message
> passing code, on the other hand, is hard to debug.  I don't care what
> language it was written in.  The proper tools, like TotalView help a lot,
> but distributed acynchronous code is just plain difficult to debug.
> 
> --Doug
> 
> On Sun, May 24, 2009 at 7:37 PM, russell standish 
> wrote:
> 
> >
> >
> > Most of the time this comment comes up, it seems to mean "C++ is not
> > _just_ object oriented". It is capable of being used in many different
> > programming styles.
> >
> > FWIW, C++ programs written in a pure OO style are hard to understand
> > and debug. OO is a useful tool in the toolbox, not the panacea of
> > everything.
> >
> > Cheers.
> > --
> >
> >
> > 
> > Prof Russell Standish  Phone 0425 253119 (mobile)
> > Mathematics
> > UNSW SYDNEY 2052 hpco...@hpcoders.com.au
> > Australiahttp://www.hpcoders.com.au
> >
> > 
> >
> > 
> > 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

-- 

Prof Russell Standish  Phone 0425 253119 (mobile)
Mathematics  
UNSW SYDNEY 2052 hpco...@hpcoders.com.au
Australiahttp://www.hpcoders.com.au

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

Interesting that you'd say OO C++ is hard to debug.  With the proper tools,
I've found it as easy as, well, interpreted LISP.  Now distributed message
passing code, on the other hand, is hard to debug.  I don't care what
language it was written in.  The proper tools, like TotalView help a lot,
but distributed acynchronous code is just plain difficult to debug.

--Doug

On Sun, May 24, 2009 at 7:37 PM, russell standish wrote:

>
>
> Most of the time this comment comes up, it seems to mean "C++ is not
> _just_ object oriented". It is capable of being used in many different
> programming styles.
>
> FWIW, C++ programs written in a pure OO style are hard to understand
> and debug. OO is a useful tool in the toolbox, not the panacea of
> everything.
>
> Cheers.
> --
>
>
> 
> Prof Russell Standish  Phone 0425 253119 (mobile)
> Mathematics
> UNSW SYDNEY 2052 hpco...@hpcoders.com.au
> Australiahttp://www.hpcoders.com.au
>
> 
>
> 
> 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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread russell standish

On Sun, May 24, 2009 at 06:35:36PM -0600, Douglas Roberts wrote:
> Not to digress, but Dave kind of lost me one day at a FRIAM when he said
> "C++ is not object oriented."  I didn't really know what he meant, because
> I've been using C++ for about 20 years now to accomplish polymorphism via
> object inheritance, containment, and method specialization (with and without
> templates) -- which use pretty much meets most definitions of OO programming
> that I've encountered.
> 
> Dave, I'd be interested in knowing what you meant...
> 
> --Doug
> 

Most of the time this comment comes up, it seems to mean "C++ is not
_just_ object oriented". It is capable of being used in many different
programming styles.

FWIW, C++ programs written in a pure OO style are hard to understand
and debug. OO is a useful tool in the toolbox, not the panacea of everything.

Cheers.
-- 

Prof Russell Standish  Phone 0425 253119 (mobile)
Mathematics  
UNSW SYDNEY 2052 hpco...@hpcoders.com.au
Australiahttp://www.hpcoders.com.au

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

Not to digress, but Dave kind of lost me one day at a FRIAM when he said
"C++ is not object oriented."  I didn't really know what he meant, because
I've been using C++ for about 20 years now to accomplish polymorphism via
object inheritance, containment, and method specialization (with and without
templates) -- which use pretty much meets most definitions of OO programming
that I've encountered.

Dave, I'd be interested in knowing what you meant...

--Doug

On Sun, May 24, 2009 at 6:20 PM, Stephen Guerin
wrote:

> On Sun, May 24, 2009 at 5:47 PM, Douglas Roberts 
> wrote:
> > Interesting.  Other issues that will come to play with an ABM of the
> > intended scales you describe are synchronization of the various
> asynchronous
> > distributed components, message passing latency, and message passing
> > bandwidth.  Hopefully a course-grained sync & message passing design can
> be
> > developed, because http is not good for either latency or bandwidth
> (using
> > Myrinet or Infiniband for comparison).
>
> Yeah, I'm not thinking this would be used for a single large-scale ABM
> for exactly the synch issues you describe.
>
> This would be more for authoring and deploying many smaller-scale
> applications written with an agent-oriented perspective. What Dave
> West talks about when he refers to how object-orientation was
> originally conceived not how current object-oriented programming is
> done. This is close to what Smalltalk/Seaside looks like but probably
> implemented within Javascript.
>
> -S
> --
>
> --- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
> stephen.gue...@redfish.com
> (m) 505.577.5828  (o) 505.995.0206
> redfish.com _ simtable.com _ sfcomplex.org _ lava3d.com
>
> 
> 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
>

-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Stephen Guerin

On Sun, May 24, 2009 at 5:47 PM, Douglas Roberts  wrote:
> Interesting.  Other issues that will come to play with an ABM of the
> intended scales you describe are synchronization of the various asynchronous
> distributed components, message passing latency, and message passing
> bandwidth.  Hopefully a course-grained sync & message passing design can be
> developed, because http is not good for either latency or bandwidth (using
> Myrinet or Infiniband for comparison).

Yeah, I'm not thinking this would be used for a single large-scale ABM
for exactly the synch issues you describe.

This would be more for authoring and deploying many smaller-scale
applications written with an agent-oriented perspective. What Dave
West talks about when he refers to how object-orientation was
originally conceived not how current object-oriented programming is
done. This is close to what Smalltalk/Seaside looks like but probably
implemented within Javascript.

-S
-- 

--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
stephen.gue...@redfish.com
(m) 505.577.5828  (o) 505.995.0206
redfish.com _ simtable.com _ sfcomplex.org _ lava3d.com

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

Interesting.  Other issues that will come to play with an ABM of the
intended scales you describe are synchronization of the various asynchronous
distributed components, message passing latency, and message passing
bandwidth.  Hopefully a course-grained sync & message passing design can be
developed, because http is not good for either latency or bandwidth (using
Myrinet or Infiniband for comparison).

--Doug

On Sun, May 24, 2009 at 5:24 PM, Stephen Guerin
wrote:

> Can you please define what you mean by "scalable"?  Up to 10,000 agents?
>>  100,000?  350,000,000?  6E^9?
>> How heavy are the agents to be?
>> > than all of the above?
>>
>
> Scalable eventually to on the order of a million agents per
> Internet-connected device. An order of magnitude less for mobile phones and
> a few more for beefy servers. So maybe, I don't know, 10^9 devices * 10^6
> agents/device = 10^15 agents. This would be a distributed, non-synchronous
> agent-system running many smaller applications instead of one large single
> model (ala Episims).
>
> This will most likely be written on top of existing http and ftp protocols.
> We want to move away from the current 3-tier, (database, business rules, UI)
> application development where objects/agents are disconnected from their
> databases and their interfaces. With migrating Javascript objects between
> server, phone, browser and other visualization front ends (Unity, Flash,
> Rhino/Processing, etc), we see the potential to make a more seamless
> application development environment.
>
> On a perhaps a somewhat related note, Marko Rodriguez posted his latest
> interpretation of the Web of Data (different than the Semantic Web) on
> Arxiv.org:
>  http://arxiv.org/abs/0905.3378
>
> I'm just browsing through it but it would be a good common background
> reading for us to have.
>
> -S
> --- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
> stephen.gue...@redfish.com
> (m) 505.577.5828  (o) 505.995.0206
> redfish.com _ sfcomplex.org _ simtable.com_ lava3d.com
>
>
>
>
>
>
>
> On May 24, 2009, at 3:43 PM, Douglas Roberts wrote:
>
>  Steve,
>>
>> Can you please define what you mean by "scalable"?  Up to 10,000 agents?
>>  100,000?  350,000,000?  6E^9?
>>
>> How heavy are the agents to be?
>>
>> > than all of the above?
>>
>> --Doug
>>
>> On Sun, May 24, 2009 at 2:01 PM, Stephen Guerin <
>> stephen.gue...@redfish.com> wrote:
>> So a few of us are exploring new ways of constructing scalable distributed
>> agent systems and are playing around with architecting a first instantiation
>> in either Javascript or in Smalltalk. We are interested in architecting a
>> system that grow and evolve without collapsing on the weight of itself, much
>> in the same way the Internet has been able to grow over the last 40 years
>> without a reboot.
>>
>> Relatedly, I was watching Alan Kay's'97 OOPSLA address <
>> http://video.google.com/videoplay?docid=-2950949730059754521>, and his
>> call for a Universal Interface Language popped out at me and I looked around
>> for potential implementations since then. Wikipedia claims there hasn't been
>> one yet:
>>  
>>
>> I was wondering if folks know of any candidates for a Universal Interface
>> Language that wikipedia authors may have missed.
>>
>> And, if we were to make our own, should we start with a REST-like protocol
>> 
>> supplemented by server-side javascript or other such animal?
>>
>> -Steve
>>
>> --- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
>> stephen.gue...@redfish.com
>> (m) 505.577.5828  (o) 505.995.0206
>> redfish.com _ sfcomplex.org _ simtable.com_ lava3d.com
>>
>>
>>
>>
>>
>>
>>
>>
>> 
>> 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
>>
>>
>>
>> --
>> Doug Roberts
>> drobe...@rti.org
>> d...@parrot-farm.net
>> 505-455-7333 - Office
>> 505-670-8195 - Cell
>> 
>> 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
>



-- 
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language

2009-05-24 Thread Stephen Guerin

Can you please define what you mean by "scalable"?  Up to 10,000  
agents?  100,000?  350,000,000?  6E^9?

How heavy are the agents to be?
> than all of the above?

Scalable eventually to on the order of a million agents per Internet- 
connected device. An order of magnitude less for mobile phones and a  
few more for beefy servers. So maybe, I don't know, 10^9 devices *  
10^6 agents/device = 10^15 agents. This would be a distributed, non- 
synchronous agent-system running many smaller applications instead of  
one large single model (ala Episims).

This will most likely be written on top of existing http and ftp  
protocols. We want to move away from the current 3-tier, (database,  
business rules, UI) application development where objects/agents are  
disconnected from their databases and their interfaces. With migrating  
Javascript objects between server, phone, browser and other  
visualization front ends (Unity, Flash, Rhino/Processing, etc), we see  
the potential to make a more seamless application development  
environment.

On a perhaps a somewhat related note, Marko Rodriguez posted his  
latest interpretation of the Web of Data (different than the Semantic  
Web) on Arxiv.org:

  http://arxiv.org/abs/0905.3378

I'm just browsing through it but it would be a good common background  
reading for us to have.

-S
--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
stephen.gue...@redfish.com
(m) 505.577.5828  (o) 505.995.0206
redfish.com _ sfcomplex.org _ simtable.com_ lava3d.com

On May 24, 2009, at 3:43 PM, Douglas Roberts wrote:

Steve,

Can you please define what you mean by "scalable"?  Up to 10,000  
agents?  100,000?  350,000,000?  6E^9?

How heavy are the agents to be?

> than all of the above?

--Doug

On Sun, May 24, 2009 at 2:01 PM, Stephen Guerin > wrote:
So a few of us are exploring new ways of constructing scalable  
distributed agent systems and are playing around with architecting a  
first instantiation in either Javascript or in Smalltalk. We are  
interested in architecting a system that grow and evolve without  
collapsing on the weight of itself, much in the same way the  
Internet has been able to grow over the last 40 years without a  
reboot.

Relatedly, I was watching Alan Kay's'97 OOPSLA address , and his call for a Universal Interface Language popped out at me  
and I looked around for potential implementations since then.  
Wikipedia claims there hasn't been one yet:

I was wondering if folks know of any candidates for a Universal  
Interface Language that wikipedia authors may have missed.

And, if we were to make our own, should we start with a REST-like  
protocol  supplemented by server-side  
javascript or other such animal?

-Steve

--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
stephen.gue...@redfish.com
(m) 505.577.5828  (o) 505.995.0206
redfish.com _ sfcomplex.org _ simtable.com_ lava3d.com

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

--
Doug Roberts
drobe...@rti.org
d...@parrot-farm.net
505-455-7333 - Office
505-670-8195 - Cell

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

Re: [FRIAM] Distributed Agents and Alan Kay's Universal Interface Language