URI style
------------------------------
0 method, poe:method
1 object/method, poe:/object/method, poe:object/method
2 poe://kernel/object/method  
3 poe:/session/event, poe:session/event          
4 poe://kernel                
5 poe://kernel/session        
6 poe://kernel/session/event  
7 stem://hub/cell/target      

Pro:
    IKC uses this.  
    Kernel can be FQDN, for auto-connect.
Con: 
    URIs aren't all that nice, really.
    Multiple ways to address the same thing (cf 1).
    Multiple Turning form 1 into form 2 is "hard"


  E-mail style
------------------------
0 method
1 method@object
2 method@object.kernel
3 event@session
4 .kernel
5 session.kernel
6 event@session.kernel
7 target@cell.hub

    or even
cell+target@hub
cell+target%hub@otherhub

Pro: 
    Kernel can be FQDN, for auto-connect.
    Easily distinguish how "far" away the target is.
        print "other object" if /\@/;
        print "other kernel" if /\./;
Con: 
    Can't easily tell a JAAS method from a POE event or Stem message.
    @ is interpolated in double quotes


  Bang-path style
--------------------
0 method
1 object!method
2 kernel!object!method
3 session!event
4 kernel!!
5 kernel!session!
6 kernel!session!event
7 hub!cell!target

Pro:
    Philip gets to say "bang-path"!
    Kernel can be FQDN, for auto-connect.
    Fewer "reserved" chars (only !)
    Allows us to do source routing (kernel1!kernel2!kernel3!session!event)
Con:
    Form 6 and 5 are a tad bletcherous
    We don't really need source routing, do we?
    Can't easily tell a JAAS method from a POE event or Stem message.
    Turning form 4 into form 6 is "hard"


  X.500 style
--------------------
0 method, /m=method
1 /o=object/m=method
2 /k=kernel/o=object/m=method
3 /s=session/e=event
4 /k=kernel
5 /k=kernel/s=session
6 /k=kernel/s=session/e=event
7 /h=hub/c=cell/t=target

Pro:
    Little ambiguity
    No multiple representations
    Can distinguish JAAS from POE from Stem... but maybe not between object
        layers... unless we add a /l=jaas to the front
    Would allow /k="use of spaces"
Con:
    Not a very sexy format.  Longer to type
    "Harder" to parse... but there are probably modules to do it for us


  XML style
----------------------
0 <Remote dest="JAAS"><Method>method</Method></Remote>
1 <Remote dest="JAAS"><Host>kernel</Host><Object>object</Object>
        <Method>method</Method></Remote>
2 <Remote dest="POE"><Session>session</Session><Event>event</Event></Remote>
3 <Remote dest="POE"><Session>session</Session><Event>event</Event></Remote>
4 <Remote dest="POE"><Host>kernel</Host></Remote>
5 <Remote dest="POE"><Host>kernel</Host><Session>session</Session></Remote>
6 <Remote dest="POE"><Host>kernel</Host><Session>session</Session>
        <Event>event</Event></Remote>
7 <Remote dest="Stem"><Host>hub</Host><Cell>cell</Cell><Target>target</Target></Remote>

Pro:
    Little ambiguity
    Uses XML
Con:
    Uses XML!  Run away!