subject:"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

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


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





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

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

Cheers, yourself.

--Doug

On Mon, May 25, 2009 at 10:06 AM, Steve Smith sasm...@swcp.com 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


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

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 mar...@snoutfarm.comwrote:

 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

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 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.

-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-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 d...@parrot-farm.net 
 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 stephen.gue...@redfish.com 
 wrote:
On Sun, May 24, 2009 at 5:47 PM, Douglas Roberts 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
--

--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
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


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

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 mar...@snoutfarm.comwrote:

 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


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

On Mon, May 25, 2009 at 11:52 AM, Marcus G. Daniels mar...@snoutfarm.comwrote:


 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

On Mon, May 25, 2009 at 3:06 PM, Carl Tollander c...@plektyx.com 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

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
stephen.gue...@redfish.comwrote:

 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:
  http://en.wikipedia.org/wiki/Universal_Interface_Language

 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
 http://en.wikipedia.org/wiki/Representational_State_Transfer
 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

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 
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.


-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


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


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

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


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


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

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 mar...@snoutfarm.com

 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


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

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.comwrote:

 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:
  http://en.wikipedia.org/wiki/Universal_Interface_Language

 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
 http://en.wikipedia.org/wiki/Representational_State_Transfer
 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

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

 http://en.wikipedia.org/wiki/Universal_Interface_Language

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 http://en.wikipedia.org/wiki/ 
Representational_State_Transfer 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

2009-05-24 Thread Stephen Guerin

On Sun, May 24, 2009 at 5:47 PM, Douglas Roberts 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
-- 

--- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
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

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
stephen.gue...@redfish.comwrote:

 On Sun, May 24, 2009 at 5:47 PM, Douglas Roberts 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
 --

 --- -. .   ..-. .. ...    - .-- ---   ..-. .. ... 
 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 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

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 r.stand...@unsw.edu.auwrote:



 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

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 
 r.stand...@unsw.edu.auwrote:
 
 
 
  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

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