[Standards] Whiteboard XEP, Gajim and GSoC2008

Fabio Forno fabio.forno at gmail.com
Thu Mar 6 11:18:30 UTC 2008

2008/3/5 Peter Saint-Andre <stpeter at stpeter.im>:
>  > Maybe not, SXE would work as a binary protocol just as well but
>  > "object synchronization" does seems like a useful general purpose task
>  > worth standardizing...
>  So the question is: does SXE basically do what we need for minimal
>  object syncronization and then people can build various applications on
>  top of that? Fabio seems to think that it doesn't quite meet his needs
>  (it does too much or not enough) but I'm not sure why...

Sorry, too much trashing in the last days, lowering my attention to
the topic.  There are two types of possible synchronizations:

- The whiteboarding (stream) style, where each entity does small
changes, modifying attributes or adding few nodes to the DOM. For this
SXE is super and it seems really easy to use, sorry if there's been
the impression I'm not fine with it. There are only two possible
"improvements" (I'm even not saying issues): find a way for the
initial synchronization, when the joining entity must get the whole
document, and a control protocol for the event stream. As you say it's
a problem to send the whole document in a message if it's huge, but if
it's huge it may be a problem to retrieve it with thousands of
messages defining the structure as well. In the xiclets stuff we are
starting thinking to get our documents using http of ibb (and we have
the usual file transfer problem... but i think that ibb can be nicer
that SXE for the initial flood; we need figures, but I've the strong
feel this is true, I could even bet few bucks :P). Therefore I think
that in SXE it should be useful to have a pluggable initial state
configuration, in which you can offer the most appropriate methods,
then after that you can go on with SXE happily. The control stuff
instead is something at a different level: I just think that as with
RTP we define also a RTCP control channel, the same should be useful
for SXE. Also in 1-1 there few meta events that are general and that
we should carry (e.g locking, errors, requests of resynchronization
from a particular point, perhaps also timing for applying changes).
However this is a different XEP and it should be possible to make it
work with SXE just using jingle in the correct way.

- the object synchronization style: as we have seen at the DevCon it's
a completely different scenario, and especially after these mails I
came to the conclusion that SXE will never be used for this, unless
making it too much complicated. In applications such as in xiclets is
the application logic that must manage node ids (and only some node
ids may be useful), adding an external layer of node ids as in SXE is
heavy and of little usefulness. Moreover when reacting to user events
most of DOM changes are applied in two ways for which SXE is either
too heavy or rigid: the app may load & replace whole new chunks or
screen or it may modify  the structure just locally (with the js code)
and send to other peer just UI events (e.g. button pressed) or data
(e.g send a form). Finally, to draw a conclusion: I stop thinking of
SXE for other applications than the whiteboarding style.

I hope to have decreased the level of confusion with this mail, if not
I'll try again ;)

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

More information about the Standards mailing list