On 16/06/13 09:29, Michael MacFadden wrote:
All,
What we would need to do to support integration with Open Office, or any
other app, is abstract our OT Core Engine in two ways. First it would
need to become a stand alone service that other apps could hook in to.
Second we would need to change the operations to be more generic than the
current set that are tied to the wave conversation model. The current OT
model is not flexible enough to become a core OT framework for other apps
to use.
Michael,
Have you had a chance to look at the SLOB layer in google walkaround [1]?
<quote>
Much of the walkaround code is not specific to Wave, but factored out as
a separate, more general collaboration layer that manages shared live
objects. These objects can be modified by multiple clients at the same
time, with changes made by any client immediately broadcast to all
others. The Wave application is built on top of this, but the live
collaboration layer is flexible enough to support other applications.
</quote>
It's apache licensed, and took at least some insperation from ShareJS.
Dave
[1] http://code.google.com/p/walkaround/
One of the things that always struck me in Wave was that the conversation
model used OT but that the gadget API did not. This is in part because
gadgets had their own data model which had nothing to do with
conversations (lines, annotations, etc) which were not supported well by
Wave's OT.
The google real time API is a step in that direction, but there are a
couple problems with it. 1) It is a javascript API rather than a service.
2) You are forced to use it's data types rather than your own, and 3) your
data must be stored on Drive.
I have seen two proprietary OT engines that seem to work well acting as a
service and one open source one. If we are to grow, I think this is the
direction the OT code needs to go in.
I think Joseph and I (so far as I can tell) are probably the two most
interested people in doing this.
I think we need to develop mini communities within wave. Those that are
focused on the OT / CC Stack, those that are focused on clients, those
that are interested in federation, etc. If we can pair up some folks that
are interested in each of these areas (and others), I think we can make
some progress.
~Michael
On 6/15/13 8:25 PM, "Yuri Z" <vega...@gmail.com> wrote:
Just a note - the rendering to static HTML is experimental and wasn't
actually submitted to official Apache Wave repo since there was no
agreement on the way on how this should implemented right without breaking
static bindings when compiling from GWT to Javascript.
On Sat, Jun 15, 2013 at 10:05 PM, Zachary ³Gamer_Z.² Yaro
<zmy...@gmail.com>wrote:
@Fleeky, Yuri actually added some
code<
https://github.com/vega113/WaveInCloud/tree/master/src/org/waveprotocol/b
ox/server/rpc/render
to
WIAB for static HTML rendering, so that could be a solution to your
publishing problems. In addition, Google Wave, Rizzoma, and (I* *think)
WIAB (with Yuri's code) support exporting to HTML or PDF. Is that what
you
were asking for?
@John, I definitely like the idea of being able to log into a wave
server
from OpenOffice and edit waves through it, but I think we need a
standardized wave client-server protocol first.
‹Zachary ³Gamer_Z.² Yaro
On 15 June 2013 12:34, Fleeky Flanco <fle...@gmail.com> wrote:
john, i was infact using wave as a google docs replacement for a
while it
worked pretty good the only problem i had with it was that i couldnt
'publish' static updates to a front facing page to share with people
who
didnt feel like registering on my wave server.
an openoffice for wave would be extremely usefull, and could have an
extremely large impact imo. wave is also already very very close to
having
this funcitonality. etherpad lite sortof already does this, but i kept
going back to wave because it was actually more responsive,
featurefull,
and actually crashed less.
On Sat, Jun 15, 2013 at 9:29 AM, John Blossom <jblos...@gmail.com>
wrote:
I had the down-the-road thought just now that I wanted to put into
circulation before I forgot about it.
One of the challenges that we will face in developing open source
Wave
is
that Google and others - but mostly Google - are out there using
operational transform technologies also. So far the Google Drive
Realtime
API hasn't had much impact, but it's being "demoed" successfully in
Drive
apps like Docs and Presentations.
The advantages of an open source Wave implementation are, of course,
that
people can own their own data and identity management without
having to
rely on a specific vendor's infrastructure. But the flip side of
that
is
that you have to look carefully at infrastructure that integrates OT
and
understand what you have to do similarly to showcase your
technologies.
That brings me to OpenOffice. At some point it will be beneficial to
consider how the Wave API can enable apps in the OpenOffice suite to
take
advantage of OT technologies in Wave and its other various
features. In
fact, it's not unthinkable that an OpenOffice for Wave variant might
not
be
feasible at some point, maintaining a familiar office automation
paradigm
as a user interface for those who relate to that sort of tool but
having
the power of Wave to drive collaborative document editing, comments,
embedded apps and so on, with Wave data structures underneath the OO
interface.
Just idle thoughts for now, but if we make good progress over the
next
several months, it's a sub-project that may help to attract more
developers
to Wave technologies.
All the best,
John Blossom
