
What's next for Apache OpenOffice - cesarb
https://lwn.net/SubscriberLink/699755/533f89639e8b53f0/
======
starseeker
From what I can see, if Apache OpenOffice wants to be a viable project with
Libreoffice already out there and well ahead from a user perspective, it needs
to focus on things that are attractive about it that differentiate it from
Libreoffice. Right now, to the best of my admittedly limited knowledge, that's
primarily their license. My thought on this is that they need to pick some
(fairly radical) directions to take the project in that will provide clear
alternatives to LibreOffice. Maybe they could review the ideas here:
[https://wiki.documentfoundation.org/Development/Crazy_Ideas](https://wiki.documentfoundation.org/Development/Crazy_Ideas)
and pick some of the more ambitious ones that Libreoffice is unlikely to
attempt.

~~~
synchronise
The best thing that could happen to the community at this point is to hand
over the Openoffice trademarks to The Document Foundation and for them to
retire the Libreoffice branding, shift everything over to the more
recognizable Openoffice branding.

That way, it would actually bring people on board who are not technical, since
pretty much no one who isn't into Linux knows what Libreoffice is.

~~~
skrebbel
This! Some people can even save face by calling it a merger, much like when
io.js "merged with" node.js.

------
ChuckMcM
I think the answer to the headline is "sadness." but the situation is
important to understand on two levels, both from technical level and from a
governance level.

In my experience, understanding governance is not something that comes easily
to engineers. This project however provides a textbook example of the forces
involved. Governance, or the right to set direction, can be imposed if the
governed are prevented from expressing an opinion on it or choosing an
alternative. Dictators who simply kill anyone who stands against them, small
groups where a superior assigns governance like a VP telling your group that
some person is your new manager. But actual, durable, governance only occurs
with the _implicit assent_ of the governed.

Libreoffice (LO) and Apache Open Office (AOO) both existed at a point in time
of the fork, when a portion of the governed (in this case the developers)
withheld their assent to the impositions by AOO and started LO. From that
point forward there were two options for working on open software for business
tools.

Given the choice, contributors chose the LO governance over the AOO
governance, and as a result what was the premier and leading open office
software project is now contemplating its own demise. No one person was
responsible, everyone was responsible. This sort of thing happens all the time
in all sorts of situations, whether it is countries that lose faith in their
leaders, or startups that are suddenly involuntarily losing all their staff,
or open source projects that stop being relevant.

From a technical level this is a tremendous validation and condemnation of the
power of open source. The ability to fork the software and produce a better,
more secure, more maintainable product is huge. I have had the opposite
experience of watching a proprietary program I really liked die because the
"owner" of the software lost interest in maintaining it. It was frustrating to
be unable to contribute to its survival.

But it is also a condemnation in the form of how open source is so loosely
governed, there was no effective process of keeping it from getting to the
fork or die state. There doesn't exist any sort of neutral arbitration board
that would allow troublesome developers who were out of sync with the governed
to be removed from the project. I believe that is part of the reason we have a
dozen different window systems for Linux.

So bottom line is that it is a sad day for the once dominant Open Office
platform, but a very good learning experience for the community.

~~~
cesarb
> Libreoffice (LO) and Apache Open Office (AOO) both existed at a point in
> time of the fork, when a portion of the governed (in this case the
> developers) withheld their assent to the impositions by AOO and started LO.

I'm sorry, but this is wrong. LibreOffice was started almost a year before
AOO. Take a look at
[https://en.wikipedia.org/wiki/LibreOffice#History](https://en.wikipedia.org/wiki/LibreOffice#History)
for details.

~~~
Grishnakh
That's basically quibbling, though the OP did err in his history a bit. AOO
existed before that point too, it just wasn't called AOO and it wasn't part of
Apache; it was run by Oracle, and before that, Sun. It was still the same
project before Oracle dropped it on Apache. The portion of the governed were
mad at the impositions by _Oracle_ , not Apache, and started LO. A year later,
with almost no developers left and all the Linux distros having switched to
LO, Oracle finally threw in the towel and gave the dying OO.o project to
Apache, where it became AOO, and the few people still hanging in there yell at
clouds.

~~~
maccam94
> That's basically quibbling

It's absolutely not quibbling, the OP framed his whole post around the
governance of Apache OpenOffice vs LibreOffice:

>> Libreoffice (LO) and Apache Open Office (AOO) both existed at a point in
time of the fork, when a portion of the governed (in this case the developers)
withheld their assent to the impositions by AOO and started LO.

>> Given the choice, contributors chose the LO governance over the AOO
governance

>> No one person was responsible, everyone was responsible.

No, Oracle was DIRECTLY responsible (with some blame falling on Sun). Oracle
dumped OpenOffice on the Apache project when it became obvious that their
continued involvement would not be profitable.

>> But it is also a condemnation in the form of how open source is so loosely
governed, there was no effective process of keeping it from getting to the
fork or die state.

No, this was a CLEAR condemnation of Oracle as a steward of open-source
projects, and a good example of the community pulling together when the
governance structure stopped working.

~~~
ChuckMcM
For what it is worth, my comment is, in essence, that the "power" of
governance flows from the governed and that the Open Office project provides
us with an excellent example of how the governed can express their
disagreement with the governance. The example works because the "official"
lineage of the project is dying, while the "forked" lineage of the project is
not. It also keeps a lot of variables such as opportunity cost, market size,
Etc., the same which helps it as tool for learning.

I did NOT mean to imply that it was the Apache foundation that killed (or at
least mortally wounded) Open Office. What I was trying to state was that a
series of governance choices killed it, the breaking point can be identified
in time as the moment LO forked itself. Then from that point forward, you can
compare the governance choices made by the OO lineage, and the governance
choices made by the LO lineage, and see what worked and what did not. And that
is what makes it such a great example (in my opinion).

For people reading and following along, and who might be considering being the
steward of an open source project, they might take a moment and look at both
paths thoughtfully to understand the limitations of being "the boss" on a
project and how those limitations are manifested.

I get where you are coming from Cam, I screwed up by not pointing out it was
Oracle in charge of Open Office when LO forked, but as that screw up changes
nothing about how governance is perceived by the governed or rejected by the
governed, I expect that is why your point might be considered a quibble.

~~~
maccam94
I still must emphasize that you picked the incorrect governance system to
include in the conflict with the developers in the open source community. The
governance choices of Apache OpenOffice were largely irrelevant. Sun owned
StarOffice, and continued to pay developers to work on the codebase after
releasing it as OpenOffice.org. This justified their strong control over the
governance of OOo, despite the friction this caused for the community. Had the
community forked, it would have been uncertain which codebase would have won
(gotten the most development and usage). The governance system in this case
was not that of a pure open source community, but rather heavily influenced by
a single corporate entity.

When Oracle acquired Sun, they ceased to govern and pulled their developers
off of the project. At that point it became impossible for the community to
continue working within the existing project, so the remaining developers
forked to create LibreOffice. It is not adequate to say that "governance
choices" killed the project, Oracle killed it but held on to the trademark.

I can think of no reason why Oracle would decide to donate the OOo project to
the Apache foundation other than to generate confusion in the marketplace and
deflect criticism.

At this point, I don't think the AOO has done anything wrong governance-wise,
but there's just very little reason for LO to work with them. AOO development
is mostly stagnant, and going through another governance restructuring and
licensing change probably doesn't seem appealing to LO. I doubt the Apache
project will donate the trademark to LO because they probably don't want to
give up on an Apache-licensed project.

I do completely agree that governance requires assent by the governed, and the
project owning the OOo trademark does not have that, but your post mis-
attributed the who and the how.

~~~
sksnxjis
>I can think of no reason why Oracle would decide to donate the OOo project to
the Apache foundation other than to generate confusion in the marketplace and
deflect criticism.

For a tax break? No, those assets have already been written off as R&D. Maybe
it's just for the PR. I cannot conceive of Larry Ellison doing anything out of
altruism.

~~~
pbhjpbhj
Can you write off IPR as R&D? You could probably massively over-inflate the
value of the OO.org trademarks (and the copyrights). Donating then might be a
financial mechanism, it dumps the trademarks but also prevents others from
using them without having to use them yourself???

Oracle and Apache's accounts would show what's happening there.

~~~
Grishnakh
This is a conspiracy theory, but perhaps MS paid them off to do it this way
just to generate confusion.

------
mindcrime
In the interest of full disclosure, I am a contributor to AOO, albeit one who
has not been as active as I should have been in the past. Which makes me part
of the problem. But that aside...

Rumors of the demise of AOO are _very_ premature. Some internal speculation
aside, there's no particular reason to think the project _will_ be shut down.
Yes, the ASF board wants to see certain things happen, but none of them are
things that all of us don't also want to see. Security fixes being released in
a timely fashion? Of course we want that. Frequent releases? Yep. Awesome new
features? Hell yeah!

So the question is, can we get back to a place where we can deliver those
things? I think so. And here's some reason why:

1\. This recent "retirement" discussion has served as something of a "call to
arms" or rallying cry for some AOO contributors. Count me among their number,
just to show an example. I'd been pretty slack about contributing, but this
has motivated me to get off my arse and get busy doing stuff. And I don't
think I'm the only one.

2\. We've had a number of new contributors, or at least potential new
contributors, show up in the past week or so.

3\. We're starting a new, more focused recruiting effort to recruit developers
to the cause. Perhaps _you_ yourself have given some thought to working on an
OSS office suite? Here's a great chance!

4\. We have had a release manager volunteer step forward to manage the 4.1.3
release.

5\. A lot has happened just in the last week in terms of cleaning up
documentation around the build process and clarifying issues there. I think
it's safe to say we want to make it as easy as possible for new (or existing)
contributors to build and run AOO.

Now the realist in me demands that I acknowledge that we still face a tough
slog ahead. But nobody said this stuff was easy. And I feel confident that we
can get this project back on track and re-establish it as the world's most
awesome office suite.

Anyway, again, please consider getting involved now if you have any interest
in office suites. And this is especially true for Mac users, as we could
especially use more help from people who can build and test on the Mac
platform.

~~~
ploxiln
AOO IS NOT MAINTAINED. It can't do builds, it can't make releases. It can't
apply a security bug fix and build a release within 9 months. For an office
suite, that's not OK.

LO is where all the active OpenOffice developers went to, LO is the
continuation of OO.o.

AOO is an old and unmaintained snapshot of OpenOffice, with an apparently
long-broken release build process.

I don't think there should be just one office suite, or even just one open
source office suite, and I don't think everyone should just use the one with
the most features. Not at all. But the AOO situation is just tricking people
unfamiliar with it, to use the OO.o from 3 years ago instead of the OO.o with
security and other fixes, and updates for compatibility with new operating
systems (and new features which may or may not be desired).

If you hate LO developers or project, maybe you have some good reasons, and
you should be able to work on a competitor based on whatever open-source code
base you want. But the right thing to do at this point is abandon the
"OpenOffice" name. Random people looking for "OpenOffice" need to be
confronted with the fact that there are now two forks, LibreOffice and
something else. And, at least for today, they should definitely choose
LibreOffice.

~~~
zanny
The real, non-political competitor to the OpenOffice lineage has always been
Calligra[1]. It sees dramatically less development, but it is also one of the
KDE related projects that has a knack for using its toolkit to dramatically
reduce its own code bloat - what takes hundreds of thousands of lines of
reinventing the wheel in OO/LO is several hundred lines of extremely well
maintained Qt data structures.

Even when the zombie AOO dies it does not mean the end to competition in the
free office suite space. Even beyond Calligra there are some Gnome based
efforts and third party projects (including web based ones) that provide
similar tools. There is no shortage of competition, and if there were ever a
slowdown in LO we would just see another fork akin to the Oracle escape.

[https://www.calligra.org](https://www.calligra.org)

~~~
smellf
> Calligra

That webpage though. If I told my aunt to download Calligra she would have no
idea what to do once she got there. You have to click the tiny "Get Calligra"
in the upper right, then scroll down and click "For MS Windows" in the middle
of a list, then read through a list to find the download that's actually
Calligra, then download the right msi for your architecture. Compare that to
openoffice.org, and then to libreoffice.org, and watch the page get better and
better for aunts everywhere.

> several hundred lines of extremely well maintained Qt data structures

Sounds amazing to me, I may try it out too. But people who aren't tech
literate and are looking for a free alternative to MS Office know OO.org, and
that's the real crux of the issue - OO.org is effectively dead. If OO.org
instead redirected to libreoffice.org with a little disclaimer, more people
would be using better free software.

The OO.org codebase isn't going anywhere. But Apache has a responsibility to
its users and its reputation, and IMHO they should redirect the OO.org domain
to LO.org, and let the community decide if the original OO.org codebase is
worth resurrecting.

------
okket
Looks like this well end up like X.Org/XFree86 (yes,
[http://www.xfree86.org/](http://www.xfree86.org/) still exists)

Edit: I should have reloaded before posting, the argument is much better made
by Grishnakh above.

~~~
geofft
"Exists" is a strong word. The CVS link
[http://www.xfree86.org/cvs/](http://www.xfree86.org/cvs/) is a 404 (and, uh,
is CVS), the FTP server isn't accepting anonymous logins, and the HTTP
releases URL is giving the most amazing 404:
[http://ftp.xfree86.org/pub/XFree86/4.8.0/binaries/](http://ftp.xfree86.org/pub/XFree86/4.8.0/binaries/)

~~~
smellf
How is their 404 page Yahoo? Do they use yahoo for hosting??

------
exhilaration
The discussion from a few days ago on this topic was pretty informative:
[https://news.ycombinator.com/item?id=12411747](https://news.ycombinator.com/item?id=12411747)

------
jimjag
It is a shame that the article is behind a paywall; it sounds as if it is a
very well balanced article.

There seems to have been many things that people forgot about when following
the previous thread
([https://lwn.net/Articles/699047/](https://lwn.net/Articles/699047/) and
[https://news.ycombinator.com/item?id=12411747](https://news.ycombinator.com/item?id=12411747)),
which I hope to relate here:

1\. The whole issue was an open and honest DISCUSSION. Many people took this
as an indication that AOO was dead. I fear that my own response to Dennis'
post on-list went a bit too far in reinforcing that (mis)belief but the lack
of (perceived) developer energy was the basis for the whole discussion. Dennis
did not say "AOO is dead, what should we do" but rather that the AOO community
should discuss, __as a contingency plan __what a retirement would look like.

I may plan or discuss my funeral (or final wishes), but that does not mean I
am dead or dying. :-)

But think about this: what other project would be so open and candid? Such
openness, and the true appreciation that discussion be done in __public __is a
core part of the Apache Way. It 's also a core part of what open source work.

2\. Because of this "publicity", the AOO has been overwhelmed by lots and lots
of offers of support, which have been graciously and thankfully accepted.

3\. People have also forgotten that choices, even in FOSS, are a Good Thing.
LibreOffice is very successful, and they should be congratulated for their
success. But certainly there is room for other players in this game, and
certainly room for one (or more) that are under a permissive license. The
thing is is that they don't have to be __clones __; they can have different
audiences, different "missions" so-to-speak.

4\. It is sad when we in the FOSS community degrade ourselves to simple, base
license-wars. There are good, solid reasons for permissive, weak copyleft and
strong copyleft, and I've contributed to them all.

IMO, what's next for Apache OpenOffice is what the Apache OpenOffice community
decides; it sounds as if this whole kerflunkle has served as a kick-in-the-
arse to the AOO team: they see how important AOO still is to numerous people,
and they have loads of new volunteers offering to help. A 4.1.3 release is
forthcoming so that is good news and a step in the right direction.

~~~
cyphar
> But certainly there is room for other players in this game, and certainly
> room for one (or more) that are under a permissive license.

Why is "like $X but under a permissive license" something that people champion
for? Are we not all in the same boat, trying to replace proprietary software
so users can live in freedom? Permissive licenses simply do not help achieve
this goal as effectively as copyleft licenses do.

If you want to argue that AOO will be technically superior or whatever, that's
fine. But championing "we also allow proprietary forks" is not helping any
users of free software.

~~~
nkurz
_Permissive licenses simply do not help achieve this goal as effectively as
copyleft licenses do._

I use to share that view, but I'm no longer sure if this is true. Do you have
evidence you could point to, or is this a instinctual opinion? I don't have
evidence going the other way, but I don't think it's a clear cut truth.

~~~
cyphar
> Do you have evidence you could point to, or is this a instinctual opinion?

The Sony PlayStation is based on a fork of FreeBSD. It is entirely
proprietary. Lots of different embedded device also use BSD because they are
permissively licensed. Anybody who gets such a device is screwed because they
cannot modify it or even know what the device is doing. This is true for the
majority of IoT devices (which is a serious problem going forward). To be
fair, there aren't nearly enough GPL enforcement lawsuits as there should be
(which is why I donate to the Software Freedom Conservancy) so it's not like
the copyleft side is /much/ better but at least copyleft does help achieve the
goal.

In addition, GPLv3's anti-tivoisation clauses are quite unique in the free
software world and are _specifically_ written to ensure that users have
freedom over devices that try to undermine the spirit of the GPL. You won't
find any permissive license that has such protections for your freedom
(because it's not enforceable without making the license copyleft).

This argument doesn't hold for standards, generally. Because what matters for
a standard is _adoption_. Sure, you're making it possible to have a
proprietary fork of your reference implementation but at least users can be
sure that the specification is actually used (and if the spec is Apache
licensed then you're safe from patents which is something that can't be said
of proprietary specifications). But Apache OpenOffice isn't a standard, so
this is not really all that relevant.

------
woodandsteel
AOO supporters want to get more developers working on it. But I think whether
or not new developers decide to do that is going to depend greatly, for most
of them, on whether or not they think AOO is going to succeed in the future.

So let me ask the AOO supporters, where do you predict that AOO will be in a
year from now, and two years? And give some specifics, like code clean-up,
infrastructure, security fixes, new features, and so on.

And finally, if a year from now, AOO is far behind what you have predicted,
will you still keep telling people that AOO is going to be a success? And
ditto for two years from now.

~~~
mindcrime
_So let me ask the AOO supporters, where do you predict that AOO will be in a
year from now, and two years? And give some specifics, like code clean-up,
infrastructure, security fixes, new features, and so on._

I'll only address the things I have knowledge of / intend to work on.

I am working now on getting a dedicated server setup for running code analysis
tools / fuzzing tools /etc. against the AOO code-base. My plan is to make this
an automated process that runs frequently (although the exact details remain
TBD) and delivers reports that the AOO developers can use to improve code
quality and security. It is my hope that this kind of initiative can help make
a major improvement in the quality of the releases.

From a feature standpoint, I have some ideas regarding integrating Calc more
with the "Big Data" ecosystem, which - coincidentally - largely revolves
around the ASF. A lot of the ideas aren't fully fleshed out yet, but I am
picturing Calc as a front-end for working with various analytics processing
engines. I think that at one time there was an Uno based R integration for
Calc, so I'd also like to look at where that stands and see if that could use
some work.

Also, I _hope_ that we can dramatically improve the build system and
associated documentation to make it markedly easier for new developers to grab
the code, produce builds and get going. But I don't know that that's an area I
personally will have much time to work on, plus there are other people working
on that anyway.

I think we'd all like to see more frequent releases, so definitely put that
down as a goal at least.

I have some other random ideas percolating in my head as well, but if I talk
about them, somebody will interpret that as a commitment to deliver them, and
since I probably can't justify making that kind of commitment right now, I'll
stop here.

 _And finally, if a year from now, AOO is far behind what you have predicted,
will you still keep telling people that AOO is going to be a success? And
ditto for two years from now._

I don't tell people that AOO is or isn't going to be a "success". It already
_is_ a success by many standards, and not so much by others. I don't think
looking at it in such binary terms is productive. As long as there is one
person using the code, and one person hacking on the code (and the might be
one and the same) then I'm all for it.

------
arglwarg
Even with the "Crazy Ideas" there currently is no reason to assume they would
be blocked from being implemented, if only the resources for that were
available. So, once the hard part of finding the resources for them is solved,
why should one not put them on LO right away -- which is a much better
maintained and stable base than the aging AOO?

------
Lintaris
[https://news.ycombinator.com/item?id=2608700](https://news.ycombinator.com/item?id=2608700)

Check those comments from 5 years ago. Some managed to predict the current
mess.

~~~
davidgerard
Everything that happened was completely predicted, because it had just
happened with Apache Harmony when IBM pulled out of that.

