Re: Anyone can say anything about anything

Hi Sarven,

This was a really useful email to me!  I appreciate you taking the time
to explain the situation.

Sarven Capadisli writes:

> Having said all of that, it is good practice to follow the definitions 
> in the ontologies/vocabularies (e.g., pay attention to what the expected 
> domains and ranges are) in order to play along with how other people are 
> publishing and consuming data. For example:
>
> <http://example.org/bar>
>    a foaf:Person , gr:Location .
>
> doesn't make much sense if you want machines to figure things out on 
> their own. Not to mention it is pretty awkward to come up with a 
> sensible UI for humans. However, making that statement in and of itself 
> is not wrong. Re: anyone can say anything about anything on the Web. We 
> try to be nice, and do what we can to have interoperability but there is 
> no policing on what we get to say. The trust layer is outside of all 
> this. If you trust example.org's statements, or find it useful, that's 
> up to you. For example, example.net may make statements about 
> example.org. It is up to the consumer to decide (based on its own 
> decision-making process) how to handle it.

I think this last paragraph is probably the most interesting to me.
Like it or not, a federated network probably doesn't know much about the
intent behind the representation of some activity, so even though it's
up to the publisher to decide how to structure things, it might be hard
for a machine to determine how to present that... which might end up
with surprises to end users!

Handling extensible systems in a non-vague way was part one of two of my
original reasons for raising this.  The other one is that there's a high
chance that ActivityStreams objects may be represented in a
"traditional" object-oriented style representation where you have
classes and subclasses, and an object has one class, but that class may
be a composite class.  Now, there may be other ways to represent this,
but for example PyPump has an Image() object, and we have various
methods on that.  How in Python, to represent something with multiple
classes?  You *could* forego the python class as a representative of
activitystreams object types paradigm, though it does feel friendly to
have access to it.  In my current activitystreams library I'm hacking in
Guile scheme, I initially used "GOOPS", an object oriented system, to
lay out the classes, but moved away from that system so I could make it
more functional... so it turns out I have some flexibility there.  But I
guess the "types as classes" method, though appearing as an obvious
choice, isn't as feasible as I'd expect!

Anyway, figuring out how to resolve what types take precedence... is
there documented suggestions on how to best handle this?

 - Chris

Received on Friday, 14 August 2015 21:08:10 UTC