[Standards] Whiteboard XEP, Gajim and GSoC2008

Fabio Forno fabio.forno at gmail.com
Mon Mar 3 22:15:35 UTC 2008


2008/3/3 Peter Saint-Andre <stpeter at stpeter.im>:

>  We had some discussion about this at the devcon last weekend. E.g. some
>  people were interested in extending SXE to be a generalized method for
>  synchronizing XML instances (e.g., for DOM events or whatever). The
>  conclusion we came to was that defining a protocol for what we called
>  "object synchronization" is hard (e.g., conflict resolution is a
>  difficult problem), but that it may be easier to define a protocol for
>  what we called "event stream synchronization" (just send the change
>  notices in order and let the receiving application figure it out).

More than hard it is impossible to define a general protocol handling
all types of conflicts and synchronization issues. It's an aspect
related to the application logic and therefore all application have
different requirements

> We
>  even went further and wondered whether any of this work is in scope for
>  XMPP and whether it makes sense for us to define an XML protocol for
>  every problem under the sun. They don't do that in the web world (e.g.,
>  there's no XHTML extension for whiteboarding or whatever), instead they
>  use technologies like JavaScript and Flash for applications that run on
>  top of HTTP+HTML.

That's the reason for which we started the API ML, in which we're
trying to defining a similar execution model within XMPP clients.
We're just at the beginning, so I think that if you just want a
working whiteboard now that's not the path yet. Perhaps you may give a
look at Sameplace which has a whiteboarding plugin based on svg and
it's executed in a web page inside firefox, but I don't know how it's
handling XML events, not had the time to study it.

>  I'm not quite sure what the implications of the devcon discussion are
>  for our work on SXE and whiteboarding, but it strikes me that there
>  would be consensus for something less ambitious (the XML eventing
>  protocol) rather than an advanced protocol for conflict resolution,
>  rollbacks, etc.

What I don't like of the current SXE definition is the inability of
sending the whole document or chunks it, instead of being obliged of
sending all the necessary events for recreating the document. We found
the W3C's REX was able to handle this case, but there are problems
with patents apparently. W3C is also working o REX2, but I've found no
further reference about the fact they are working on it...
Finally a consideration I forgot at devcon: we can't define
arbitration logic within the protocol, but at least we can define a
mechanism for out of band control of the flow, as RTCP is for RTP. For
example if A sends to B  an inconsistent change (it's B that decides
that the change is inconsistent, but at the transport level we don't
have to know why), B should be able to send a message to A telling:
hey, I haven't accepted any changes since... let's try to figure out
what's happened.
I think that this could be a step towards a common approach to
whiteboarding, though applications must still be hardcoded in the
clients

-- 
Fabio Forno, Ph.D.
Bluendo srl http://www.bluendo.com
jabber id: ff at jabber.bluendo.com



More information about the Standards mailing list