Hacker News new | comments | show | ask | jobs | submit login
Restructuring a giant, ancient codebase to make LibreOffice work well everywhere (fosdem.org)
489 points by buovjaga 8 months ago | hide | past | web | favorite | 101 comments



Thank you for sharing this article. Speaking personally, it comes at a great time. I've been toying with the idea of getting involved in open source, and was particularly interested in pushing forward open source office suites.

Something that I'm particularly interested in with LibreOffice is helping the core being decoupled from the UI, to both help with portability and to speed up the rate of UI innovation. I had thought that I may have to start by myself, but based on this article it seems that the current LibreOffice developers are thinking along similar lines.

If any LibreOffice developers are reading this, are there any sub teams setup that may be a good fit? To give some idea of my background, I would describe myself as a tester that knows how to code (not in C++ alas, but I'm familiar enough with debugging at a low level).


Regarding the UI, there are certainly some... curiosities. To give you a random anecdote from the trenches: https://bugs.documentfoundation.org/show_bug.cgi?id=107087#c...

"It's challenging to fix as one needs to tunnel certain data through 20 layers of abstraction, but hey, that's improved UX for you!"

If you want to get into triaging bugs, I welcome you with open arms. I am desperate to get us more helping hands as after nearly 10000 analysed reports I am anxious to diversify.

Here is the index of our QA tech articles: https://wiki.documentfoundation.org/QA

Basic debugging info for triagers: https://wiki.documentfoundation.org/QA/BugReport/Debug_Infor...

Debugging for devs: https://wiki.documentfoundation.org/Development/How_to_debug

Binary bisecting: https://wiki.documentfoundation.org/QA/Bibisect

If you were thinking of working on the UI, please get in touch with the design team, which includes some devs (but could really use 10 more!): https://wiki.documentfoundation.org/Design

You will find me in the QA IRC channel (and most others): https://wiki.documentfoundation.org/QA/IRC

I'm heading to sleep now, though, but I hope to see you around!


> "It's challenging to fix as one needs to tunnel certain data through 20 layers of abstraction, but hey, that's improved UX for you!"

It it's truly 20 layers of abstraction, I'd love to read a blog that spelunks into all those layers and elucidates what they do.


Started in 1988, but since around 2012 we have started to streamline it.

The layers work like this:

1. Old cross platform layer for both operating system specific functionality (OSL) and runtime specific functionality like string handling and bootstrapping (RTL).

2. UI code base is the Visual Components Library (VCL) - Window handling, event loop, controls (e.g. buttons, etc), etc.. This is divided into a platform specific part and a non-platform specific part (allows for easier porting).

3. “Starview Library” (svl) and toolkit Library with extra widgets, etc.

4. SFX2 (Starview Framework v2) dies things like dispatches messages, creates a “shell” for each program.

After that I get a bit lost, it it’s mostly app specific stuff.

There’s also a component model baked in called UNO (Universal Network Objects) which is a network transparent component hosting environment - it’s what allows the use of Python and Java, with obviously a C++ specific purpose environment. It’s kind of cool, but also many folks don’t want to use it any more than necessary.

I think it helps to understand that it was a German company who created StarView, they really though in terms of layering :-)


I vaguely remember that StarDivision (the original company) offered separate licenses for the VCL as a cross-platform UI library in the 90s. If memory serves, it was available for DOS, Windows, OS/2 and Solaris back then.


And MacOS. It was reviewed by Dr Dobbs magazine, wish I had the original library source code! I’m a bit of a Libreoffice code historian, but there is no source code history before the year 2000...


Not sure if you'll see this since I'm a bit late, but I have two questions:

1. I've been wondering this for a while but never knew who/where to ask, but where's the original StarOffice code dump? What actually got dumped? I'm fascinated by that whole transition timeline, both in terms of its own history and also as one of many code dump events. (One of these days I'll go learn about Mozilla.)

2. Are there any interesting tidbits floating around? Any old DOS-era or early-Windows-era code, for example? I wonder if (with great effort) I could build something for Win3.1. (Of course I realize I'm not describing LO at all here)

2000 is pretty old, as tech goes, surely something fun got captured. The only reason I can see for super-old code not floating around somewhere is that it was explicitly excluded.


Actually, maybe not for Windows 3.1 (it did run in this) but there was a shim layer where the developers inplemebted something called uwinapi. Thus implemented NT functions for Windows 95 and 98, and in fact it was used layer for a few functions that didn’t work in Windows XP but did in Vista.

There is a whole bunch of code in the SAL that works for OS/2 but it has maintenance overhead. Both uwinapi and the OS/2 port have been removed from Libreoffice.

As for a code dump before 2000 - man, I would love that. But sadly, it doesn’t exist. The Star/Sun/Oracle guys chanted VCSes a few times. They had a procedure for merging patches into the trunk that was insane - and we have lost the history of those branches so from between 2001 to 2009 the code becomes harder to follow.

Unfortunately, there are decisions that were made before 2000 but that’s lost to us now due to a lack of version history from before this point.


I see, wow. Thanks for the info.


Do you think someone (with a programming background) can help in say, 2 to 4 hours by just jumping in, or am I going to cause more harm than good?


Honestly: yes. LibreOffice is quite a friendly place, and there's even a list of beginner bugs that help with getting your foot in the door. They like new developers.

It might take more than a few hours (e.g. you'll need to set up a dev environment - but the builds are quite robust nowadays unlike some projects), and the codebase is complicated - but contributing to LibreOffice was fun and helped me gain real world software experience. I'd only worked on small personal projects before LO.

You definitely won't cause harm, and there are devs who will try to help you get your patch submitted. (They even employ someone to help new contributors get up to speed and to help get their patches in.) As chris_wot said, get on irc and people will generally be able to help you get set up. (IRC presence tends to vary by time and day, jfyi.)


The first step is setting up the build environment on your operating system and completing a successful build. Depending on your computer, the build might run for 4 hours :)

The articles on building are found in the General Programming Guidelines box in this index: https://wiki.documentfoundation.org/Development

Then you will want to pick an easy hack: https://wiki.documentfoundation.org/Development/EasyHacks Note that there are more challenging easy hacks marked by the difficultyInteresting keyword. This step also implies you will create an account on the Bugzilla.

If the easy hack is not an ongoing thing, you should comment on the Bugzilla report about your desire to work on it and assign it to yourself and change status to ASSIGNED.

If the easy hack is an ongoing task, you might want to check https://gerrit.libreoffice.org/ if there are some unmerged patches related to it by searching for message: and the bug number. This will allow you to be confident about avoiding duplicate work.

To start working on your patch, you typically create a new branch:

git checkout -b my-branch-name

as advised in the "Sending a Patch to Gerrit" section of this: https://wiki.documentfoundation.org/Development/gerrit

The topic of amending patches is dealt in this additional article: https://wiki.documentfoundation.org/Development/gerrit/Submi...

Easy hacks come with mentors attached to them, so the patch reviews should not get stuck in a limbo. Regarding "normal" patches, they might sit there even for some weeks, but I hope the situation improves when TDF hires the new developer mentor(s): https://blog.documentfoundation.org/blog/2017/11/07/job-sear...

Btw. there is a job search for feature implementation going on: https://blog.documentfoundation.org/blog/2018/01/16/tender-c...


Hop onto IRC - #libreoffice-dev on Freenode


This articulates almost every experience I've had with trying to contribute my time to any open source project that has any size. I really think I've figured something out that'll help. I spend many hours getting X codebase to compile / work on my machine. I fix said issue and feel great about it! It never even gets looked at and/or it gets smashed to shreds with criticism by the same person that submitted the feature req / bug / whatnot.


This doesn't have much relevance for LO. Devs there are generally welcoming. You'll still get honest feedback but they generally want your code in the codebase, and want to help you get it in a shape to land it.


I feel you, especially as someone with a bit of social anxiety any time I think I'm doing something helpful or useful (like writing this comment), because that concern is always in the back of my head. I don't have any particularly good advice that you likely haven't read or heard before, but sometimes it's useful to read/hear it from others who've been in the same boat.

In my experience, and this goes doubly so for small FOSS projects, you have to remember that it's someone else's baby. Maybe they were the person who started it, maybe they've been there since the early days, or maybe they have an unusually strong attachment or sense of ownership over whatever it is you're changing. At any rate, the moment you submit a patch, there's always the risk that it may be met with harsh criticism (sometimes deserved; sometimes not), and at least part of that may be the nature of the human psyche. So, the best defense is to do things by the book, if there's an established process, or failing that, persistence. Sometimes, just the existence of a patch in the wild--even if it isn't accepted by the developer--can be enough to motivate them toward a fix. I've seen plenty of relatively minor fixes get rejected only to be fixed hours later by a maintainer because the patch got them thinking.

Let's be honest, even if it bruises the ego a little: As a user, I don't care how it gets fixed. I'm not in it for the glory. I just want it to work.

There's of course the usual advice [1]: Keep your pull requests/patches short and targeted. Don't try to do too much, because larger, more widely reaching patches are likely to be ignored or turned down. Document what you can, why you did what you did, and what you intended to fix; but don't be too verbose (guilty, as you can see here!). Asking follow-up questions is instrumental if it's rejected, because there's probably something that was missed or overlooked. Of course, this doesn't obviate issues with projects that have a distinct lack of communication skills or toxic personalities. Ironically, I've had some luck with non-committal/non-responsive maintainers by forking small projects, applying my changes and moving on, only to find some weeks later that they want to pull my changes. In those cases, I never expected a fix--I just needed it to work yesterday--and I needed somewhere to publicly source the fixed copy from. That upstream wants the resolution as well is merely an added bonus.

But the key is (polite) persistence. It's also the hardest to do if you don't want to seem rude or pushy. I also think that rejection and criticism play on our fear of failure (whether or not we admit it), which may kill participation. Just don't give up: Think of the other users who don't have your skill set to fix the underlying problem and consider that you're advocating for them!

[1] https://www.atlassian.com/blog/git/written-unwritten-guide-p...


Well, skip the anxiety, because this is good advice :)


Thank you very much for the overview! I'll check out the QA IRC this weekend, and look through the links you've shared. Hope to see you around too. :-)


You need to study the VCL (Visual Component Library). This is actually divided into a sal (system abstraction layer) which is the bit we can port so we can use it on different platforms (Windows, GTK+, KDE, OS X). Then there is the "stable" (I say that advisedly) bit, which is based on the OutputDevice class, which spawns the Printer, Windows and VirtualDevice classes.

The best thing that could happen at the moment is for OutputDevice to be gotten rid entirely - it's a leaky abstraction.


Thank you for the advice, gives me a good idea of where I should start.


He has a slide deck [1] that he links to in the interview, where he tries to highlight some challenges with grokking large codebases, and techniques one can use to compartmentalize understanding and build from there. I found it both a bit too colloquial yet also too opaque, but there's some useful nuggets in there.

It also speaks to a significant problem: large codebases are inherently difficult to understand, which forms a barrier to entry. This is despite the fact that most software makes use of various abstractions to break problems into smaller parts.

In the general sense, I believe it's worth thinking about how the particular abstraction mechanisms used in software impact a new contributor's productivity, vs. the productivity of someone more familiar with the codebase, especially for projects that are developed in the open, or with high developer turnover.

[1] https://people.gnome.org/~michael/data/2016-04-29-solving-pr...


What's opaque about "write everything down, including your assumptions and what you are going to try before you try it, write it out in full, and don't worry too much about it being in a neat structure because it's more of a scratch-pad"?

His main point is that we focus too much on the software tools, and not enough on how we think about the software we are modifying.

I can say from experience that writing things out on paper without looking at the code works, and more people should do it. Like he states in the slide-deck: it lets you off-load mental burdens, and avoid the problem of forgetting the details of a complex problem in the process of being unravelled. It lets you get back into the work weeks or months later.

Writing messy pseudo-blog-posts in github issues and very long code comments is how I kept my sanity on a project where I was the sole programmer for two years.


I've always found abstraction to be a double edged sword when trying to understand codebases. Sometimes it helps define the intent, but other times I'm going "WTF is this thing for real?" and tracking the abstractions through several files.

My favorite is tracking down a member function and being completely confused until I realize that I missed one of the layers and it was overridden in that instantiation.


I generally find that abstraction is good, but layering is bad. Let's say I have components A, B, and C that all do something useful and are good abstractions, the difference between good code and bade code is how they interact. In bad code A will call B and B will call C, from the top level it's completely opaque how everything fits together. I'd much rather A returns something and let's the caller pass it to B. There is very little difference in code required but it makes a world of difference to making it comprehensible.


IMO the most important thing when introducing a layer of abstraction is the name of the new component. I sometimes spend 2 or more minutes making up a name that best describes what this layer is about.

ProTip: Manager or Controller is not a good name. To me a good name is eg „PostDetailSerializerResolver“ - it’s a component that will resolve serializers for post detail objects. And according to concept of single responsibility, it should only do that. If you need it to do more, you must change the name.


> I sometimes spend 2 or more minutes making up a name that best describes what this layer is about.

Some of the best refactoring I ever did for long-term code-maintenance was nothing more than untangling a web of abstraction layers and renaming them to fit the actual context, changing nothing to the functionality of the code.

Sometimes you start out with an idea for what the architecture will be, but then things change and the naming isn't updated.


We tend to speak of abstractions in only positive terms. Some negative ones could include opaque, obtuse, disjointed, etc.


When I think of abstractions I think abstraction == API and good API design is very hard.


> ..it's worth thinking about how the particular abstraction mechanisms used in software impact a new contributor's productivity, vs. the productivity of someone more familiar with the codebase, especially for projects that are developed in the open, or with high developer turnover.

Oh yes. I work on this[1], and require very little inducement to talk about it[2].

[1] http://akkartik.name/about

[2] For example: https://news.ycombinator.com/item?id=13565743#13570092


It's so amazing that the dinosaur LibreOffice/OpenOffice is still maintained. From the codebase, it is probably similarly old-fashioned like Thunderbird. Some folks may say it is hopeless to modernize. For me it does not even matter whether that's true or not -- it is a well-done and partially timeless and universal tool in my everyday work flow. While there are fancy and modern alternatives like the (closed source) Google Docs, LibreOffice always stays as a fall-back solution if nothing more works. Thank you for this work, developers!


I recently discovered that Microsoft literally will not sell you Office for a computer not connected to the internet. You cannot buy this product, I tried very hard, lots of escalation, etc.

Needless to say, LibreOffice works very nicely in an offline environment, and it's very rare that I find a file it does not handle well. (The only example I have — a Word document with Track Changes enabled, heavily revised by multiple people, multiple times over many days. L.O. seemed to lose track of the changes and showed a wrong document. I imagine for most people this is pretty rare.)

And you don't have to worry about malware (for those tempted to pirate Microsoft Office).


You can still activate it by phone, it just tells you it can't be: https://support.office.com/en-us/article/-telephone-activati...


I'm a bit confused by this. Microsoft normally has excellent offline activation capabilities for all the three letter agencies that buy their software and run it on internal networks.


Enterprise editions exist with 100% offline installation, but unfortunately, home and business licenses have an "offline install" that requires online activation...[0]

This has been a huge PITA for me since I often need Word and Excel on a computer that's restricted from accessing the internet.

[0]: https://support.office.com/en-us/article/Use-the-Office-2016...


This is a bit kafka-esque:

> You need to be connected to the internet to download this installer file, but once that's done, you can then install Office offline on a PC at your convenience.

> ...

> After your Office installation is complete, you need to activate Office. Be sure you're connected to the Internet and then open any Office application, such as Word or Excel.

I mean the lede is "problems with slow speed or unreliable connections" but at the same time ... offline is offline.


Precisely my thinking (based on supposition). Adobe provides similar activation for offline computers (a sort of challenge/response where you take a number off the offline computer, enter it on their website on a different computer, bring a number back to the offline computer to finish activation).

I assume they just have decided to make this functionality a special case for enterprises of a certain size. I emphasized to them this could be bought through a business channel if needed but I assume I have not the right scale.


That’s only available with an EA, which means 250 seats or more.


The most crufty part in both mozilla's code base and libreoffice code base is essentially equivalent in that it tries to solve essentially same set of problems (cross-platform UI and object model), but the implementation is significantly different, because in mozilla's case this layer of cruft was introduced 20-ish years ago as a complete rewrite of the thing (and most of the really ugly hacks have to do with sub-par C++ compilers and support for classic MacOS), while there was no attempt at a major rewrite of the staroffice codebase until libreoffice (and it is quite obvious that the way libreoffice's rewrite proceeds is at least partially motivated by experience from how the netscape->mozilla rewrite suffered heavily from second system effect and in the end failed at least from the bussines standpoint).


Good point. Indeed it is interesting to follow the Firefox Quantum approach (which breaks with XUL) or KDE's open source office suite, aka Calligra (https://www.calligra.org/) which is "plain C++/Qt" and thus not a sole effort to solve the cross-platform UI/object model problem such as Mozilla and StarOffice did in their time. Thanks to this, Calligra devs can probably concentrate much more on implementing features while getting a modern cross-plattform UI for free (literally: Qt is free).


I use LibreOffice calc every time I need to export an Excel spreadsheet as csv, because you can specify double quoted fields and you can specify UTF-8 encoding. I think this is a major use for LibreOffice, moving enterprise data into a web CMS. I work on a dataset with a lot of foreign characters and LibreOffice is my savior.


Gnumeric includes a tool named ssconvert that does this sort of thing from the command line, very handy. Gnumeric doesn't have the mindshare of Libreoffice but you may find this simplifies your workflow so I thought I'd mention.

Edited


Gnumeric also requires very little RAM or CPU so it's very light-weight compared to LibreOffice Calc. I don't use spreadsheets that often but when I do, it serves my needs adequately and it works with most of the keyboard short-cuts that I'm used to from Excel and LibreOffice Calc.


Curious - do you mean it's old fashioned because it's a desktop application, and not a web app? There are actually hosted on-line versions, e.g. https://demo.collaboracloudsuite.com/tdfnextcloud/index.php/...


When I wrote "old fashioned", I refered primarily to the look-and-feel but also the status of the code base (+20 years), the fact they don't use a widespread UI toolkit but rolled their own, etc.


I'm quite surprised that the markup incompatibility with Microsoft Office is still an issue. Are they actively sabotaging the Open Document Foundation, or is it just really difficult to achieve?


I don't think they need to actively sabotage anything and I would not want to dwell on those lines of thinking. I think a large part of the open issues are in corner case territory or due to the freedom of users to go wild with their document layouts, creating a mess of nested frames in tables etc. Let's roll up our sleeves and fix them anyhow :) !!

Here is our meta report for MSO formats: https://bugs.documentfoundation.org/showdependencytree.cgi?i...

"depends on 1394 open bugs" - this includes all the further meta reports.


The OOXML specification is over 5K pages long. Even Microsoft's own online products do not implement it entirely. One should not be surprised that outside parties may face challenges achieving 100% implementation and interoperability.


and even word/excel has discrepancies between 2003, 2011, 2013 and 2016 especially between 2011 and 2013. Mostly overlapping layouting is differently.


It's really difficult to achieve.

The article mentions EMF/EMF+. this format is basically a list of calls to GDI.h and is a bitch to map to other graphic stacks when you are not on Windows.

The specification of the format is public (kudos for Microsoft), it helps a lot. But there are a lot of corner cases and the spec can be quite hard to understand some times. Computing correctly the origin is tricky for example (VIEWPORTORGEX, WINDOWORGEX etc).

For some stuff, it's impossible to get it right.

One example that comes to my mind is a text encoding bug I got a year ago (I maintain an emf to svg conversion library). It took me one week to track it down. In most cases the strings are UTF-16. But in weird cases, when the ETO_GLYPH_INDEX flag is set, the "encoding" is directly the index of the glyph inside the selected font.

It's not the most portable way to handle text... If you don't have the exact same font on your computer, there is a good chance the text will not be displayed correctly.

And converting back to a well known encoding is tricky (using the cmap tables of the ttf file, you have to build a reverse cmap, pray there is a 1-1 mapping between glyph and unicode, and convert back to utf-8 or something).

Even Microsoft itself, on the Mac OS, version got it wrong.


Can you link to that library?


I found it in his submission history: https://github.com/kakwa/libemf2svg


thanks ^^

For information, the bits of code that is handling "font index encoding":

https://github.com/kakwa/libemf2svg/blob/master/src/lib/emf2...

To

https://github.com/kakwa/libemf2svg/blob/master/src/lib/emf2...


I think we might a similar issue - thanks!


Realistically LibreOffice is not really relevant competition for Microsoft. Google Docs is much more important, even though the capabilities are so widely disparate.


I guess that depends on your filter bubble. I know many more people who use LibreOffice compared to Google Docs. Most people I know don't trust the cloud with their important documents.


I do not trust cloud even with unimportant documents. Especially if you can be locked out of your cloud account without reason. I only keep non critical offsite backups on cloud drives.


A very long time ago, I used to work on document importing and exporting on Word Perfect so I'm relatively familiar with the problem in general. I haven't looked at this stuff in almost 20 years, so I have no idea about specifics at this point :-)

What people generally don't understand is that the save file formats do not describe what the output will look like. Back in the old, old, old days you would write a word processor and to "save" the file, you would just write a binary image of your data structures. That was what the doc file format was originally.

Although, people didn't tend to program this way back then, imagine a Rails server. Now imagine that you handed over your database (with tables that correspond to each model object). That's kind of analogous to a "save" file. In order to render the data, you need the business logic (which, in Rails, is usually housed in the controllers) and you need the rendering logic (which is usually housed in the views). Just having a description of the database tables doesn't really help me all that much in rendering the data as you can see.

Now imagine that we take a different Rails app that happens to do the same kind of thing. Some people say, "Oh it would be swell if you could import the data from the first Rails app and render it in yours. You are basically doing the same app, so it should be easy". But it's obviously not -- I wrote my controllers and views completely differently than the other Rails app. My model objects contain completely different data and are structured completely differently. Even worse -- I don't even render things the same way. If I want to support this functionality, I basically need to completely rewrite my rails app to be exactly the same as the previous Rails app.

And this is essentially the problem. If you want to render Word documents the way Word does, you basically have to rewrite Word in your word processor. If you also want to support your format then you have to maintain 2 word processors. If you want to supports some other file formats? It just gets worse and worse.

So what you could do is completely rewrite the rendering engine so that it is more flexible. But the problem is that this is a massive undertaking and nobody will believe you if you tell them that it is necessary. Even worse, there is a surprising amount of variation in rendering. For example, how do you deal with page breaks in footnotes? Most people don't write footnotes that are longer than a page (if you look at my posting history, you might suspect that I'm one of those people, but I digress). However, it's very common in the legal field. There is a specific correct way to break pages in footnotes and Word historically has not done it correctly. They do it differently. This is actually what kept Corel/Word Perfect in business for a long time -- in order to print the document, you would have to use Word Perfect and since the file conversion was crap, you pretty much had to keep it as a Word Perfect file forever.

I will say that while I worked on Word Perfect, Microsoft was very helpful in explaining how their formatter worked. They even regularly sent us bug reports when our import filters had regressions, etc. I've never believed that they intentionally obfuscated the process. It's just a difficult problem.


Wow - some great experience; it would be great to have your help improving the Document Liberation wpd filters - we do a great job there, but no doubt improvements are always possible - particularly with better understanding =)


Is compatibility more of a problem with .doc or .docx? .doc shouldn't still be evolving, I'd imagine.


.doc is more stable, but it's also much more onerous to be fully compatible with. .docx was at least designed as a reasonably modern, rational document format with a specification. .doc by contrast evolved from generations of MS Word that for efficiency saved files by doing raw dumps of internal data structures as binary blobs, which got more and more complicated as things accreted over the years and versions. And there was no public documentation of the very complex binary format until 2008. Joel Spolsky has some on that here: https://www.joelonsoftware.com/2008/02/19/why-are-the-micros...


The JPEG file formats are nearly as bad, especially once you get into camera vendor extensions. It was common practice back then. Just take a bunch of C structs and dump them from memory to disk.


Have Microsoft completely solved compatibility between different/same versions of MS Office now?


Nope, I ran into word documents that word could not render just last month. And I hardly use word; I edit about 1-5 docs per month.


It took my enterprise almost a year to iron out the issues to move from 2010/2013 to ProPlus/2016.


::Are they actively sabotaging the Open Document Foundation, or is it just really difficult to achieve?

The former is a more likely scenario


I'm not surprised at all that someone on HN replies to a positive story about some open-source product with unrelated bug complaints, then implies the bugs are due to malice on the part of the developers.


My worst downvotes have been when I'm referring directly to the motivations or knowledge of the commenter. My second-worst downvotes are when I'm opining on something I know nothing about. My suggestion (to myself, and anyone else interested) is to avoid these two pitfalls.


I think he meant Microsoft...


d'oh! I'll leave my comment up as a warning to others to reread carefully before getting annoyed.


I'm trying to document the internals:

https://chrissherlock1.gitbooks.io/inside-libreoffice/conten...

I've also been, on the quiet, go through the commits and summarise it better. Before 2009, there was this insane way of grouping commits and it makes it hard to know who did what to the code!


Would be nice to restructure the article next to make it readable on mobile.


Reader Mode in Safari works well on this.


I recall seeing a Google tech talk over ten years ago where they talked about cleaning up OpenOffice (or was it StarOffice?) it was memorable because they mentioned it did #define private public. I’m impressed they kept at it and it sounds like it’s going well. Still glad it’s not my project, though :)


Sounded unfamiliar, so I checked. The Apache OpenOffice sources indeed have three such lines left (all in obscure fairly irrelevant parts of the code; two inside odd #ifdefs that are never true, one inside their OS/2 (yes!) backend). LibreOffice naturally hasn't any such crap any longer.


Do you know why both Apache OpenOffice and LibreOffice still exists?


History. Check the Wikipedia article.


Michael Meeks is a wonderful guy, love his "Up early..."


Personally wish people would stop tinkering with the UI - polish but do not tinker/change needlessly. Case in point being that Linux likely remains fringe as a desktop platform simply because of it's continual tendency to morph on the UI side of things.

Then again, Win10 is going down the same route so maybe it will all even out (...).


You mix UI and UX polish, and the UX on OpenOffice is honestly not very good ... I only had to use it the other day and struggled with finding half a dozen things that are just obvious with Word.


* obvious to Word users

For complete novices, yes the UI is not very intuitive. But Word isn’t much better either.

I recently had to start using Word again at work and even though the ribbons seem intuitive and user-friendly, actually finding the feature I needed has not always been easy. I’ve had to Google quite a bit (the help is excellent though).

At least in LibreOffice everything is always in the menus and does not suddenly disappear if your window is not wide enough.


Office now has a command search box.


I can recommend this read: https://careerfoundry.com/en/blog/ux-design/the-difference-b...

UX doesn't enter into my criticism here.


What does Linux (the kernel) have to do with UI? Unless you are creating kernel extensions, you don't directly interact with the Kernel?

You mean Gnome 3? There are other desktops.


"There are other desktops" is a symptom of endless tinkering with the UI.


Or a recognition that one-size-fits-all doesn't work.

Different desktops have different goals.


I completely agree. I like having choice too. But for mass adoption you need a polished solution that works out of the box, not a bunch of Lego. The answers to users complaining shouldn't be "have you tried alternative software X?"


I think Gnome being the next default for Ubuntu will solve that problem, but mass adoption requires more than that.


Exactly this yes.


Generally I find their suite pretty full features and functional. There are occasional conversion snafus with MS formats, but honestly that is less on them and more on MS.

In all honesty, my biggest issue is that Calc can slow to a crawl when a sheet gets even moderately large, especially if using filter/sorting.


I’ve upvoted you - this sort of feedback is invaluable! Do you have an example spreadsheet? If you could log a bug and upload it, that would be helpful.


Open a LibreOffice Calc doc. Put a 1 in A1. Drag down to a thousand or so. Then drag to the right replicating that series out to say LL. On my decently beefy laptop (i7 quad core, 16 GB RAM, 8 Gb RAM free) it slows to an absolute crawl. On my server (16 dual threaded cores, 64G RAM), it can handle quite a bit more before slowing to a crawl.


laptop windows. Server Ubuntu



I'll see what I can do. Is there a suggested place to upload?


Luckily he mentions ongoing multithreading work in the calc :)


I love these sorts of projects and solving these sorts of problems. However, I don't have time to work on an Open Source project, and can't due to employer restrictions anyway. So I get out my inner refactoring by going to the Code Review Stack Exchange [0]. Check it out if you want to do some analysis of a small self-contained piece of code.

[0] https://codereview.stackexchange.com


This reminds me of a presentation[0] from Microsoft at CPPCon about using the same giant ancient Office codebase on iOS and Android as on Windows.

0. https://cppcon.org/bonus-talk-cxx-in-ms-office-2014/


Error:Execution failed for task ':createStrippedConfigMain'. > A problem occurred starting process 'command 'D:/android/mobile-config.py''


Are you trying to build the Android Viewer on Windows? I believe no one has ever done that, so I recommend you to stick with Linux: https://wiki.documentfoundation.org/Development/BuildingForA...


Try doing that with your dynamically typed language.


It's really not going to be easy either way.




Applications are open for YC Winter 2019

Guidelines | FAQ | Support | API | Security | Lists | Bookmarklet | Legal | Apply to YC | Contact

Search: