hi Ben,

Thank you for the link to the patch.  I will certainly have a look at
this.  Can you elaborate on what problems were found when not using
the server acknowledgement (is there a discussion thread somewhere on
this?  I couldn't find one.)

One thing that is not clear from the Google Wave white paper on OT is
when acknowledgements are sent from the server to the client.  What
I'd like to determine is if operations are sent from a number of
clients to the server concurrently, or, does the server make clients
take turns in sending operations to the server.  Though I haven't done
the math yet, I would expect that if clients send operations
concurrently to the server and the server maintains only a single
state space, then the OT transformation functions would need to
satisfy TP2 (which is avoided in the Jupiter system).  If I'm not
right here, are there any resources around that formally prove
correctness in the OT approach of Wave that I can read?

Cheers,

Dan


On Nov 18, 10:55 pm, Ben Kalman <[email protected]> wrote:
> No, the FedOne client doesn't wait for acknowledgement before sending the
> next operation -- it hasn't been an issue until recently.  There is now a
> patch in review for implementing this, 
> seehttp://codereview.waveprotocol.org/23002/show.
>
> -- Ben
>
>
>
> On Thu, Nov 19, 2009 at 12:52 AM, Daniel Paull <[email protected]> wrote:
>
> > Hello All,
>
> > I've been reading the various wave protocol white papers and wanted to
> > understand more about how the OT implementation employed by Wave
> > differs from that described in the Jupiter paper.  In particular, the
> > use of server Acknowledgements as noted in the OT white paper:
>
> > "Having a simple and efficient server is important in making Wave
> > reliable and scalable. With this goal, Wave OT modifies the basic
> > theory of OT by requiring the client to wait for acknowledgement from
> > the server before sending more operations. When a server acknowledges
> > a client's operation, it means the server has transformed the client's
> > operation, applied it to the server's copy of the Wavelet and
> > broadcasted the transformed operation to all other connected clients.
> > Whilst the client is waiting for the acknowledgement, it caches
> > operations produced locally and sends them in bulk later."
>
> > I checked out the Fedone code and started digging to try and find
> > where the client caches operation while waiting for an
> > acknowledgement, but the code that does this has not jumped out at
> > me.  Looking at ConsoleClient.java, it seems that operations are sent
> > to the server without any handshaking with the server at all.  This
> > can be seen when sendAppendMutation() is called in response to user
> > input, which in turn calls backend.sendWaveletDelta(), which invokes
> > submitRequest() on the server.  I could not find any code relating to
> > acknowledgements in the server side code either.
>
> > Is the server acknowledgement and operation caching in the client not
> > implemented in the Fedone example?  If it is, can someone please point
> > me in the right direction.
>
> > Thanks,
>
> > Dan
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups "Wave 
Protocol" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to 
[email protected]
For more options, visit this group at 
http://groups.google.com/group/wave-protocol?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to