date:20090525





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

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

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

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


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


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

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

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

2009-05-25 Thread Victoria Hughes

	Hey, as IB, I would like to point out that biological models make  
sense because we are unavoidably biological in design, thus our  
systems will be. All our systems: interpretive, expressive,  
diagnostic, experimental. No matter how far we think we may evolve  
past that, we cannot. We just think about it, with our biological  
brains. We are a self-referential species, for better or worse.
	So our models, in whatever field, will ultimately ping on that  
neurological level. Makes sense to work with that presupposition,  
since in the end we return to it.

Tory


Begin forwarded message:


From: "Marcus G. Daniels" 
Date: May 25, 2009 11:04:39 AM MDT
To: The Friday Morning Applied Complexity Coffee Group >
Subject: Re: [FRIAM] Distributed Agents and Alan Kay's Universal  
Interface Language
Reply-To: The Friday Morning Applied Complexity Coffee Group >


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




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 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] Fwd: Distributed Agents and Alan Kay's Universal Interface Language


Victoria Hughes wrote:
So our models, in /whatever/ field, will ultimately ping on that 
neurological level. Makes sense to work with that presupposition, 
since in the end we return to it.

A question of technology?

http://www.newscientist.com/article/dn3523-synapse-chip-taps-into-brain-chemistry.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 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 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

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

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


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

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 

> 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