I did the the next step to migrate the current LibreOffice extensions and templates site to a new Plone environment. I changed the multilanguage framework from LinguaPlone to the new plone.app.multilingual with Archetype support. The content of the site was reindexed after the change.

This morning I received a nice email  welcoming me as member of the document foundation.

https://www.documentfoundation.org/governance/members/

What an amazing organization, even though I am also staff and therefore paid to help new people, the Membership Committee deemed my work (assuming they looked on my voluntary work) interesting enough to invite me as member.

I am also an Apache Software Foundation member and proud of being that.

It is interesting to see the difference between the two foundations, which both are fantastic and both in general have the same aims. I find that The Document Foundation not only focusses on the people in the community, but also follows it trough in a grass root manner. Just an example, the wast majority of the donations to the project have an average of less the 10,- USD showing support from real people.

If you want to be part of a never sleeping, positive community, come and join us:

https://wiki.documentfoundation.org/Get_Involved

Hoping to see you soon.

Jan Iversen

So we’ve come to the end of the Month of LibreOffice, our campaign to credit the awesome work of contributors across the globe. And it has been a great month: we’ve seen updates and improvements across all areas of the software, from code and translations through to documentation and bug reports. So without further ado, let’s see the numbers…

Number of badges awarded: 341 – click here to see if you got one!

If you got a badge, click one of the share links to tell the world about it – or use the link to the small image to save a version for your blog or website. Thanks very much for taking part, and we look forward to your LibreOffice contributions in the future!

Here’s a chart showing how many badges were awarded as May progressed. There was a big jump at the start as lots of new names were added, but growth was steady and we could constantly see new names appearing as people made contributions to LibreOffice. This chart shows the total amount of badges awarded at the end of each day in the month:

Meanwhile, we also created a page where community members could award Barnstars to each other. These are icons to say thanks for doing a specific job, with bronze for smaller tasks, silver for bigger ones, and gold for making major improvements:

Number of Barnstars awarded: 22 – click to see if you got one!

So what’s next? Every month in the LibreOffice is full of activity, but we have some major events coming up such as the release of LibreOffice 5.2 in August and our conference in September. We plan to do another Month of LibreOffice later in the year – if you have any ideas or want to help out, join our marketing team!

• Prodded at mail; reviewed Lenny's nice copy. And ... we launched Collabora Online 1.0 - the culmination of really a huge investment to bring this first basic editing / 'Engine' version to market.
• So what does it look like:
  Of course, a great way to play with it and integrate it with your infrastructure is to download: CODE the Collabora Online Development Edition - and send patches. This comes with an example ownCloud integration, but we love to see other integrations and have many other excellent partners.
• What about Collaboration ? in our first release - we have Shared Editing - ie. many people can view, and follow a shared editing session with a single cursor, and you can take the cursor on demand. But of course, we're working on multiple concurrent editor collaboration as well - watch this space as CODE updates itself over the next months.
• Where is the code ? the CODE page has all the details, but the essence of it is - that this is all FLOSS, and all up-stream; you can build it yourself if you need to.
• This was "Made In Collabora" - with 99% of the commits to 'online' from our engineers. Nevertheless - it is squarely built on re-using the work of thousands from the LibreOffice community, as well as all of those contributing over the decades of the code-base' history - to whom we're indebted; there's never been a better time to get involved in contributing to LibreOffice.
• So - why Collabora Online ? (and this is the commercial plug). I believe we're uniquely placed to provide some huge value for our partners and customers around this code-base; here are some examples:
  • Support and long term maintenance from the authors and experts in of the code, from security issues to bug-fixing.
  • Service Level Agreements - to give you confidence in the availability of your site.
  • Integration services with your infrastructure - to make it a seamless part of your product or service.
  • Input into Product Management and feature roadmap to ensure that we build the best product for your customers needs.
  • And more eg. Marketing support, a deep commerical relationship and so on.
  My hope is that as we go to market, our partners and customers can help us to accelerate the pace of investment, and continue to deepen the richness of LibreOffice for the benefit of all.
• Beyond that - what to say ? Many thanks to the incredibly dedicated engineering team at Collabora, putting in some very long hours to make this a reality.

• Up; admin; calls; a little prodding at some calc code; bed.

Flatpak (formerly known under its working title “xdg-app”) is a cool new way of distributing images of Linux applications that run on a wide range of different distros, and run there in a secure way. I have blogged and spoken about making LibreOffice available in this format before in various places (see, e.g., these two previous blog posts and this conference talk).

Now is the time to announce availability of a LibreOffice.flatpak bundle of LibreOffice 5.2 Beta at download.documentfoundation.org/libreoffice/flatpak/5.2.0/LibreOffice.flatpak!

To try it out, do the following:

• First, you need to install Flatpak itself. See here for details.
• Second, you need to add the Flatpak repository that contains the GNOME runtime (on which the LibreOffice.flatpak depends; see here for details):

    $ wget https://sdk.gnome.org/keys/gnome-sdk.gpg
    $ flatpak remote-add --user --gpg-import=gnome-sdk.gpg gnome https://sdk.gnome.org/repo/
    $ flatpak install --user gnome org.gnome.Platform 3.20

  Update: If you use another locale than en-US, and want LibreOffice to automatically come up with a matching UI localization, additionally

    $ flatpak install --user gnome org.gnome.Platform.Locale 3.20

• Then, with the LibreOffice.flatpak file downloaded from the link above, do

    $ flatpak install --user --bundle LibreOffice.flatpak

  to install it. (Don’t worry, it does not interfere with any other LibreOffice you might already have installed on your machine, like the one shipped with your Linux distro.)

• And now you can run it, either from the command line

    $ flatpak run org.libreoffice.LibreOffice

  or by clicking on one of its icons (LibreOffice Start Center, Writer, etc.) in your distro’s application launcher.

(And if you happen to have an older version of xdg-app installed, installing the LibreOffice.flatpak bundle into it should work, too.)

Behind the scenes, the LibreOffice.flatpak links to a repository on the download.documentfoundation.org server that will get updated with later versions of LibreOffice Fresh. So once a new version of LibreOffice Fresh is released (starting with LibreOffice 5.2 proper), you can simply update your installation with

  $ flatpak update --user org.libreoffice.LibreOffice

A few items to note:

• LibreOffice.flatpak is based on the GNOME 3.20 runtime, using LibreOffice’s much-improved GTK3 backend. This should offer the most complete set of features in LibreOffice, paving the way to Wayland etc.
• The single bundle contains all localizations available for LibreOffice (as it doesn’t really affect the bundle’s overall size that much).
• Flatpak-based apps are not yet able to reach out to other applications installed on the machine (like browsers) to e.g. open URLs through them. That means that e.g. clicking on a hyperlink in a LibreOffice Writer document might not work yet. And since the LibreOffice.flatpak does not contain all the help documentation (for all the localizations!), but instead wants to use the online help through a browser, pressing F1 does not yet work, either.
• The LibreOffice.flatpak does not include a Java Runtime Environment (JRE). That means that some LibreOffice functionality that requires a JRE will not work.
• At this time, there is no Flatpak version of the LibreOffice Software Development Kit (SDK).

In the first quarter of 2016 a lot of work has been carried out by the community. On the events side, FOSDEM gathered several LibreOffice members together, and a face-to-face meeting with the Pootle team took place to discuss further fixes and enhancements needed by our localization team. In the meantime, the board has approved the budget to implement those features and work is being carried out.

The German community went to the DIDACTA trade fair (and wrote a nice report in several languages) and also attended the full week at CeBIT.

Guess what? Our Japanese team organized 14 events since the beginning of the year – kudos to them for their energy, enthusiasm and dedication! The Indian team also organized four LibreOffice meetups since January where localisation (l10n) for Garhwali and Angika began during one of them. One of the meetups was a hackathon dedicated to l10n QA. Don’t hesitate to subscribe to the LibreIndia Facebook page, as each event is announced and reported there.

And there is much more to report on what’s happening this quarter, like the hackfests in Ankara (Turkey) and the LibreOffice summit in the city of Las Palmas (Spain). I’m so happy to see the local communities invested in so many LibreOffice events.

Do not forget to check regularly the LibreOffice conference site; the local Czech team is working hard already to prepare everything, and a lot of information will be added to the site in the coming days. There is also the call for papers – submit your idea before July 15th!

On the l10n activities, LibreOffice 5.1 brought a bunch of modifications and several new strings to translate. But there will be more for the next release, 5.2, where a lot of help articles have been added or updated. A new project has been added to Pootle: now there is also the LibreOffice Online project, the newborn baby who has few new strings of its own.

• Sue, Adam & James over in the morning. Plugged away at admin, team call, patch review. Up late talking with Sue & J.

I worked on some test environment for an upgrade of the LibreOffice extensions and templates websites to the latest Plone 4 version during the last week. I had to find solutions for some issues. In the end the upgrade in my test instance were successful.

I worked on the current LibreOffice extensions and templates instance with my experience, that I got from the test instance today. I upgraded the Plone buildout from version 4.2.6 to 4.3.9. I had to fix an unexpected error during the upgrade of the instance zope database. Apart from this the upgrade runs smoothly. The LibreOffice extensions and templates websites are up again, running on Plone 4.3.9 for now.

The next step will be the change of the multilanguage framework to a newer Plone add-on.

• Mail chew; admin; team call, lunch, team call; admin.

So the first week has finally concluded. It was a week of balancing. Balancing between my exams and my project. I promised myself that I would focus on my exams and start my work from 7th . I ended up breaking the promise I made to myself.

So the summary of the week is that I have Implemented Code for border Import. It hasn’t been merged into the master not because the code wasn’t working or I was just too lazy to do the work but because I had done some coding style mistakes like sandwitching operator between 2 tokens (eg: if (a==b)) . Multipple rejections by the code-reviewer to merge my code has left me very happy. Im a happy because I learnt something which I would have never learnt by myself. These are the things that neither competitive programming teaches you nor your proffessor.

Writing Code is like writing an essay. You have to be very clear with your thought and convey your thought with that much clarity to the reader. There were times when choosing a variable name seemed difficult task. I dedicated alot of time to things like these (which otherwise seem trivial) but would help someone else understand the source code.

I still have some exams left So would continue with the rest of the work from 7th June. I would go for number formatting and cell protection in the coming week. Thanks for reading. Have a nice day(or night).

• Off to NCC; ran kids work with J. back for a roast lunch. adjusted bikes & pumped up tires, out for a family ride across the heath; back to watch Moonfleet together. Out to Nigel & Sue's wedding party; babes up late; fun.

I updated the test-website for the new LibreOffice extensions and templates repository with my latest developments today. I worked on four additional validators and fixed some issues in the view templates for the content. I added also a new theming add-on, based on the default Plone 5 theming product, named Barceloneta. The test-site is available at  http://vm141.documentfoundation.org:9090/liboexttempsite.

Despite the sunny weather I found some time and created and published a new release of the Plone add for the extension part of the new LibreOffice extensions and templates website. The add-on is available in the ‚Cheeseshop‘ (https://pypi.python.org/pypi) yet.

Although I had to diversify my focus for various reasons in the last weeks I managed to work through some smaller remaining topics of the Plone add-ons for the new LibreOffice extensions and templates website. I already created a new release for the templates part and uploaded it to the ‚Cheeseshop‘. A new release for the extension part will follow soon.
Besides this I created a new theming add-on for the website based on the default Plone 5 theme, Barceloneta, that could be improved later.
I also worked with the user/contributor of the current site, started the preparation of the site stuff for the migration to the newer framework. I did some work on the buildout environment for an upgrade to the latest Plone 4.3 version. I’ll run this upgrade during the next days, once all tests are completed.

Why not use this summer to enhance your job chances ?

When you apply for a development position in one of the bigger companies, changes are high that they will look at your opensource involvement. They expect to see something in your CV, and might also have a look at openhub.net.

The LibreOffice project is one of the biggest opensource projects and very well known, with a multi million user base around the world. The libreoffice community is a vibrant set of volunteers who welcomes new people.

We have people dedicated to help you get started (I am one of those), and we have furthermore identified simple problems to be solved easyhacks together with a recipe for success getInvolved

If you decide to join our community, you will be able to write in your CV, that you have worked on a project with more then 7 million lines of code. If you are active in our community  and need references we can help with that.

Let us together make the world just a little bit better and you get an extra point on your CV.

Feel free to contact me if you have questions or comments.

Have a nice summer.

Jan Iversen

This is my first blog related to my Google Summer of Code project with Libreoffice. I would be working on the Template Manager of Libreoffice to solve the basic software design problems which were quite surfacing in it’s previous instance. I have been assigned two mentors for my project, Mr. Yousuf (Jay) Philips and Mr. Samuel Mehrbrodt, who will guide me and review my ideas. This blog mainly focuses on keeping all the proposed changes under one roof and will be followed by a series of related blog posts about the actual changes made in LibreOffice.

The Template Manager will undergo a major rework and installation of new features. Few insights to the changes and additions are given below:

• UI concept:

  1. Redesigning the Template Manager

     • New User Interface for better UX
       • Remove the feels of a file manager
     • Fuzzy Search and Filter controls for easier accessibilty
     • Use of context menus instead of toolbox controls for non-browse focused entries
     • Removal of tabs (Drop 90’s design)
     • No regression on previous functionalities:
       • Non-browse focused functions (Edit, Set As Default, Delete, etc)
       • Browse focused functions (Move, Export, Import)

     • 

       Template Manager mock-up

  2. Making Impress A UX Princess

     • Scrap off the ‘Presentation Wizard‘ from Impress module
       • Exclude Libreoffice 5.2
     • Modal dialog for template selection
       • Minimal version of ‘Templates‘ dialog
     • ‘On’ by default with easy means of disabling
       • Impress > Tools > Libreoffice Impress > General > Start with wizard

• Challenges:

  1. Improve Save as Template workflow

     • Current workflow fails to use Template Manager efficiently
     • Plan to create a new ‘Save as Template’ dialog

  2. Better integration of Template Manager with Start Center

     • Improved accessibility of templates in Start Center
     • Reduce back-end to minimal code
     • Better thumbnail previews

  3. Integration of online templates

     • Not decided yet ( Not mentioned in GSoC project proposal )
     • The current LO site does not provide with API
     • New website (not launched) has a JSON API
       • Search API link
       • Search query result

  4. CMIS Integration

     • Currently an experimental feature
     • Tools > Options > LibreOffice > Advanced > Enable Experimental Features
     • Not sure about interoperability w.r.t. templates.

For other queries and discussions, please comment or ping me (IRC nick: Akki) on libreoffice-dev / libreoffice-design channel on Freenode.

Before going into the details of the marketing activities, The Document Foundation (TDF) is proud to announce that Mike Saunders was hired as Marketing Assistant in mid-February. Mike is known for the famous feature videos he made for LibreOffice 5.1, and he has kicked off the Month of LibreOffice Contribution in May, amongst many other projects. Welcome on board, Mike!

Paraphrasing a famous song, marketing at The Document Foundation is “the activity that never sleeps…”. The first quarter is one of the busiest, as we have FOSDEM and one major release happening between the end of January and mid February, followed by several minor releases – to keep up momentum – and a few events, including CeBIT in Germany.

FOSDEM 2016 was a large success for LibreOffice, thanks to the strategic positioning of the booth in the main lobby of building K, where most of the large projects are represented. It was the first time for TDF in the “kernel” of the exhibition, and it showed up. On Saturday, January 30, the project registered more visitors than during the entire FOSDEM 2015 (and almost as many on Sunday, January 31).

On Saturday, January 30, TDF developers were also on stage during the Open Document Editors DevRoom, with over 20 different talks about the upcoming LibreOffice 5.1 release, and related topics.

During FOSDEM, the certification committee also hosted several sessions, mostly via remote connections, to evaluate five candidates: one from Spain: Pasqual Milvaques, one from Taiwan: Frankling Weng, and 3 from Italy: Paolo Dongilli, Antonio Faccioli and Diego Maniacco.

One week after FOSDEM, the marketing team coordinated the announcement of LibreOffice 5.1 on Wednesday, February 10. During Monday and Tuesday, I hosted five different conference calls, with journalists from Europe and the United States. Thanks to this effort, the media coverage has been excellent, with hundreds of positive articles worldwide.

One year later, the improvements to the distribution of press releases based on specific features of phpList are showing up, with an average hit rate often higher than 30%. Thanks to phpList for offering us a free account.

In March, the marketing team has focused on two different projects: CeBIT in Hannover, the largest high tech trade show in Germany, and TDF 2015 Annual Report, which is the most important document produced by the project during the year.

CeBIT is the largest German trade show, and most visitors already know the office suite or even use it. Even if the interest has been lower than in the past, several project members – Thorsten Behrens, Thomas Krumbein and myself – have had the opportunity to present LibreOffice at the open source area, thanks to the collaboration with CIB.

TDF’s 2015 Annual Report will be released during the second quarter, and will provide an overview of what has been achieved by the project at large – i.e. including native language projects at local level – in each area.

Starting from May, we will be organizing a monthly PR call, to involve native language communities in marketing activities. In addition, starting from July, we will also organize online webinars to share competences in marketing and communications with local communities. During these webinars, we will also cover the LibreOffice migration protocol.

LibreOffice is a big project, with over 7 million lines of source code and hundreds of developers, testers, translators and other contributors spread across the globe. With so much activity going on, it can be difficult to keep track of recent developments – so here are a few pointers to keep you in the loop.

Upcoming releases

The current supported release of LibreOffice is 5.1, and the latest bug-fix version is 5.1.3. There are three more bug-fix updates due this year, so see this wiki page for information on the release schedule. The last planned update will be 5.1.6, due in October.

Meanwhile, the development team is working hard on LibreOffice 5.2, which is scheduled to be released in the first week of August. A beta version (for testing) is due very soon – keep an eye on this blog for more information. You can also see a mid-development list of new features in 5.2, but bear in mind that everything is subject to change!

Team calls

Many teams inside the LibreOffice project have regular audio or video calls to catch up, share ideas and ask questions. These teams also share minutes (notes) from the meetings afterwards, so that others can keep track of news and developments.

For instance, the Engineering Steering Committee (ESC) usually has a call every Thursday to discuss technical aspects of the project: release engineering, new features, quality assurance, mentoring new developers, and other matters. Minutes from these are posted on the projects mailing list – see the archive here (search for “minutes of ESC” for recent calls).

Similarly, the Design Team holds regular Hangouts to discuss user interface changes and usability enhancements. Then there’s the Infrastructure Team, which has calls to talk about the hardware and software that’s used by LibreOffice contributors, and the Documentation Team, which has just started regular calls to coordinate content and bring in new writers. Minutes from all of these teams are also posted on the projects list.

Finally, The Document Foundation’s Board of Directors has regular meetings to discuss organisational aspects: finances, budget requests, the yearly conference and so forth. Minutes from these meetings are available on the wiki.

Annual Report

A good summary of last year’s activity in the LibreOffice project is provided in the Annual Report. This is currently being worked on, and will have detailed updates from the native language projects, hackfests, development and QA teams, plus information on donations received throughout 2015 and other aspects of the project.

We’ll post an update on this blog when the 2015 Annual Report is available – meanwhile you can read about what happened in LibreOffice during 2014 in the previous report.

While The Document Foundation is best known for LibreOffice, it also backs the Document Liberation Project. But what exactly is that? We’ve made a short video to explain all…

<iframe allowfullscreen="true" class="youtube-player" height="570" src="https://www.youtube.com/embed/JSqU2Wp-neQ?version=3&amp;rel=1&amp;fs=1&amp;autohide=2&amp;showsearch=0&amp;showinfo=1&amp;iv_load_policy=1&amp;wmode=transparent" style="border:0;" type="text/html" width="960"></iframe>

Due to network restructuring at Hetzner, pumbaa will not be available during between 25 May 2016 23:00 hours (CEST) and 26 May 2016 05:00 hours (CEST) for a maximum of 5 minutes.

The following services are affected:

• Redmine
• @documentfoundation.org mail-adresses
• private mailing lists

This month of May is quite unique for the LibreOffice project. It has been decided that May would be a month dedicated to celebrate both LibreOffice and its community of volunteers. The project is awarding badges and barnstars matching several kinds of contributions and activities; volunteers will be able to harbor them on their own webpage, twitter handle and other social networks platforms. It’s important to understand that this isn’t a “feel good” operation. Volunteers, just like anybody else, want to feel appreciated, especially when nothing forces them to contribute to such a project. By doing so the community acknowledges the contributions of its members.

It also helps spread the word about LibreOffice. Remember, Free/Libre & Open Source Software does not directly produce products. Rather, it develops and releases software through community of contributors, that may then be monetized in one way or another – or perhaps not at all. In other words, this means that the distinction between outbound and inbound marketing that is commonly found in the corporate world is more blurry as any user is also a potential contributor. Marketing our community really means marketing LibreOffice itself. This is what we’re doing this month and it makes me happy. I’m excited at the stats and figures that we will draw from this experiment. If you happen to be a LibreOffice contributor, or just a fan of LibreOffice, you could get a badge. All you need is to contribute to the project in one of the several ways described here and it will be awarded to you: remember, we’re already at the end of the month!

Flatpak is the new name of xdg-app. So following up on my previous LibreOffice in a Box post, here is some more technical detail on how an upcoming LibreOffice 5.2 will be available as a Flatpak bundle.

There is now a shell script demonstrating how to do all the downloading of sources, building, and bundling up. I decided against using flatpak-builder (nee xdg-app-builder) for that mostly out of convenience, mainly because the way LibreOffice fetches its external dependencies is so different from the typical way of building a Linux app. So I felt more comfortable doing these things manually, calling the raw xdg-app build steps from a script. But given enough pressure (e.g., to make the LibreOfficeKit widget buried within the LibreOffice installation set available to other Flatpak apps), this might get revisited.

The script proceeds in six steps (see the above link for details):

First, building LibreOffice requires an Archive-Zip Perl module not found in the org.gnome.Sdk we build against. The easiest solution (easier than to try and get rid of that Perl dependency in the LibreOffice build machinery, that is) is to download it and make it available to the build via the PERLLIB environment variable.

Second, we need the LibreOffice sources themselves. The current master branch has all the necessary changes needed for a Flatpak’ed LibreOffice (as will the coming libreoffice-5-2 branch).

Third, we need to fetch LibreOffice’s external dependencies. LibreOffice has a long list of external projects that it can either use from the underlying system or build/bundle itself. Those external projects covered by Flatpak’s org.gnome.Platform runtime are taken from there, but whatever remains is bundled with the LibreOffice app. The sources for these external projects are normally downloaded during the build, but an xdg-app build does not have network connectivity, so they need to be downloaded upfront. So bootstrap enough of a LibreOffice build here to execute the make fetch part.

Fourth, LibreOffice is built in xdg-app. The choice of building against the org.gnome.Platform 3.20 is somewhat arbitrarty, but it’s the latest revision available. And given LibreOffice’s strong GTK3 support (which e.g. also enables running on Wayland), this should make the resulting app more versatile than basing it on the more fundamental org.freedesktop.Platform. Building LibreOffice doesn’t exactly follow the make && make install mantra, but there happened to already be a make distro-pack-install target that produces the build artifacts in (almost) the right way for our purposes here.

Fifth, the build artifacts from the previous step are assembled in the way xdg-app expects them. Some of the metadata desktop and icon files need to be renamed, to match xdg-app’s expectation that metadata files belonging to the org.libreoffice.LibreOffice app have names actually starting with “org.libreoffice.LibreOffice”.

Finally, everything is bundled up into a LibreOffice.flatpak that can be distributed to users, who can then install it with xdg-app install --bundle LibreOffice.flatpak.

The bundle contains all the available LibreOffice localizations. It doesn’t make that much of a difference for the size of the resulting LibreOffice.flatpak, and should be easier to handle for both producers and consumers than to provide dedicated single-language apps. For reasons of size, the help content is not bundled, though; the intent is to (transparently) use the online help content. However, one caveat with the current state of xdg-app is that an app cannot reach out to other applications on the machine via xdg-open (a portal will be needed for that). When asked to process “external” URLs (e.g., when clicking on a hyperlink in a text document, but also when accessing the online help), LibreOffice tries to pass those URLs to xdg-open, but that doesn’t work yet in xdg-app.

LibreOffice now has Clang -Wimplicit-fallthrough enabled to catch places where a break has been missing between cases in a switch statement. See “Re: clang -Wimplicit-fallthrough and missing breaks” for some further details.

Of course, a code base as large as LibreOffice has quite a number of places where such fall-through from one case to the next is intentional, and where warnings thus need to be suppressed. The solution is the [[clang::fallthrough]] annotation (which will be available as plain [[fallthrough]] in C++17), wrapped up as a SAL_FALLTHROUGH macro for now (so it doesn’t confuse other compilers).

All fine and dandy.

Until you realise that there is quite a number of places like the following in the code base:

Foo * p;
switch (kind) {
default:
    assert(false); // cannot happen
case Kind1:
    p = new Foo(1);
    break;
case Kind2:
    p = new Foo(2);
    break;
case Kind3:
    p = new Foo(3);
    break;
};
p->foo();

Maybe kind is of an enumeration type that can only legitimately take on one of the values Kind1–Kind3 (see “”enum union” with set of values restricted to exactly its enumerators?” for a discussion how such a type cannot reasonably be modeled in C++), or it is a type that can take on a wider set of values, but some invariant guarantee is that it will only take on values Kind1–Kind3 here. Regardless, some compilers will warn about unhandled cases, and/or about p being used uninitialized in some cases. So the default assert part got added at some point in time, logcially marking any unhandled cases as unreachable. If a compiler/NDEBUG-configuration combo is smart enough to conclude that the assert is non-returning, it will not emit a warning. If, on the other hand, the compiler/NDEBUG-configuration combo assumes fall-through to case Kind1, it will not emit a warning about p being used uninitialized, either.

All fine and dandy.

Except that, in the NDEBUG case, Clang will now warn about a missing [[fallthrough]] annotation between the default branch and case Kind1. Under non-NDEBUG configuration (i.e., assert actually expands to some code), it is smart enough to conclude that the assert(false) will never return, so it concludes that there will be no fall-through, so will not warn. But under NDEBUG configuration (i.e., the assert expands to nothing), it sees an empty statement in the default branch, causing fall-through, causing a -Wimplicit-fallthrough warning.

But when you add a [[fallthrough]] annotation to appease the NDEBUG configuration, the non-NDEBUG configuration will start to complain about an unreachable [[fallthrough]] annotation (as it considers the assert to be non-returning, see above).

Caught between a rock and a hard place.

One way out is to rewrite the code as follows:

Foo * p;
switch (kind) {
case Kind1:
    p = new Foo(1);
    break;
case Kind2:
    p = new Foo(2);
    break;
case Kind3:
    p = new Foo(3);
    break;
default:
    for (;;) std::abort(); // cannot happen
};
p->foo();

The std::abort marks the default branch as dead independent of NDEBUG. The infinite loop around it is there to make even the most lame compiler aware that that statement will not return, so it will refrain from emitting a warning about p being used uninitialized. (And the default branch can now go at the end, where it feels more naturally at home.)

And no, there should be no fears that the second variant will behave differently now in production NDEBUG builds. In the first variant, should kind ever take on an invalid value, it would silently treat it as Kind1, proceeding (though, of course, proceeding in the most unfortunate of “defensive programming” ways), not (immediately) crashing in the user’s face. In the second variant, it would abort outright (“crashing in the user’s face!”, one might fear). But that’s a red herring. The assert (and, similarly, the std::abort) codifies the invariant that kind must be one of Kind1–Kind3 here. So if it ever did have a different value, all bets about the state of the program would be off, anyway. And it would better fail fast.

In 2016, LibreOffice Conference will be hosted by the Faculty of Information Technology at Brno University of Technology, Czech Republic, and organized by OpenAlt, from September 7 to 9.

Details of Call for Papers, open until July 15, 2016, are available at:
https://blog.documentfoundation.org/blog/2016/04/08/libreoffice-brno-conference-call-for-paper/.

Registration for the conference is open at:
http://conference.libreoffice.org/2016/registration/.

The Document Foundation (TDF) announced LibreOffice 5.1.3, the third minor release of the LibreOffice 5.1 family, supporting Google Drive remote connectivity on GNU/Linux and MacOS X.

LibreOffice 5.1.3 is targeted at technology enthusiasts, early adopters
and power users. For more conservative users, and for enterprise
deployments, TDF suggests the “still” version: LibreOffice 5.0.6.

LibreOffice 5.1.3 is available for download from http://www.libreoffice.org/download/libreoffice-fresh/.

Hello, I’m Rosemary, aka roses in the IRC. This year, my project proposal with LibreOffice got accepted for GSoC. In this blog, I’ll be writing mainly about my work for the project, which is “Saving ODF XML of Change-tracking as a Sequence of Pre-defined Changes“.

Intallation of OpenCl could be a a bit difficult(compared to Nvidia) on system with Intel GPU running Linux. In this post I will tell you how to Install Opencl on Linux+IntelHD.

1. First and the very basic step is to Install OpenCl drivers for your Device. After going through a few sites I had noticed that none of them tell you to first install OpenCL Drivers. Without These , you won’t be able to execute your code on your device. Also, Intel has hidden the Opencl drivers download page for which I don’t know the reason. None the less, go here to download opencl Drivers.

2. The next thing would be to install these on your system. If your OS is RPM based then installation would be simple. If it isn’t the case then the following script would work for you.

#/bin/bash
for f in *.rpm; do
  fakeroot alien --to-deb $f
done
for f in *.deb; do
  sudo dpkg -i $f
done

1. Now, you must install opencl SDK. Both Intel and AMD have their SDK. While Intel’s SDK is closed source and only works on Intel Hardware, AMD’s SDK is open source and Runs quite good on Intel Hardware as well. I prefer AMD’s version since I was able to find more documentation and other material for OpenCl developers on their awesome site . Download AMD OpenCL SDK or you can [Download Intel OpenCL SDK]http://developer.amd.com/tools-and-sdks/opencl-zone/amd-accelerated-parallel-processing-app-sdk/.

2. Unzip the downloaded material(whether Intel’s or AMD’s both need to be unzipped ). AMD’s folder would only contain 1 shell script. Running this script with sudo would install it for every user. Intel’s folder would have a script to install from GUI. Just run that and rest is easy.

3. If you’ve installed AMD’s SDK. Then you would need to :-

cd ~/AMDAPPSDK-3.0/samples 
cmake .
cd ../bin

Suppose if your system is x86_64 you would need to do :-

cd x86_64
./clinfo

If Everything is successful , you would be able to see a big log of information about your device. Else, if you can only see some error , then it means that either there is a problem with your installation of OpenCL driver or compilation of code for your architecture.

If you have installed Intel’s SDK

You would need to open up vim . Copy and paste the following into it.

/* Copyright 1993-2009 NVIDIA Corporation.  All rights reserved.
   Modified by Mark Zwolinski, December 2009 
   Modified by Robert McGibbon, August 2013
*/
#ifdef __APPLE__
#include <OpenCL/opencl.h>
#else
#include <CL/cl.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include <sstream>
#include <fstream>

void clPrintDevInfo(cl_device_id device) {
  char device_string[1024];

  // CL_DEVICE_NAME
  clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(device_string), &device_string, NULL);
  printf("  CL_DEVICE_NAME: \t\t\t%s\n", device_string);

  // CL_DEVICE_VENDOR
  clGetDeviceInfo(device, CL_DEVICE_VENDOR, sizeof(device_string), &device_string, NULL);
  printf("  CL_DEVICE_VENDOR: \t\t\t%s\n", device_string);

  // CL_DRIVER_VERSION
  clGetDeviceInfo(device, CL_DRIVER_VERSION, sizeof(device_string), &device_string, NULL);
  printf("  CL_DRIVER_VERSION: \t\t\t%s\n", device_string);

  // CL_DEVICE_INFO
  cl_device_type type;
  clGetDeviceInfo(device, CL_DEVICE_TYPE, sizeof(type), &type, NULL);
  if( type & CL_DEVICE_TYPE_CPU )
    printf("  CL_DEVICE_TYPE:\t\t\t%s\n", "CL_DEVICE_TYPE_CPU");
  if( type & CL_DEVICE_TYPE_GPU )
    printf("  CL_DEVICE_TYPE:\t\t\t%s\n", "CL_DEVICE_TYPE_GPU");
  if( type & CL_DEVICE_TYPE_ACCELERATOR )
    printf("  CL_DEVICE_TYPE:\t\t\t%s\n", "CL_DEVICE_TYPE_ACCELERATOR");
  if( type & CL_DEVICE_TYPE_DEFAULT )
    printf("  CL_DEVICE_TYPE:\t\t\t%s\n", "CL_DEVICE_TYPE_DEFAULT");

  // CL_DEVICE_MAX_COMPUTE_UNITS
  cl_uint compute_units;
  clGetDeviceInfo(device, CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(compute_units), &compute_units, NULL);
  printf("  CL_DEVICE_MAX_COMPUTE_UNITS:\t\t%u\n", compute_units);

  // CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS
  size_t workitem_dims;
  clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(workitem_dims), &workitem_dims, NULL);
  printf("  CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:\t%u\n", workitem_dims);

  // CL_DEVICE_MAX_WORK_ITEM_SIZES
  size_t workitem_size[3];
  clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(workitem_size), &workitem_size, NULL);
  printf("  CL_DEVICE_MAX_WORK_ITEM_SIZES:\t%u / %u / %u \n", workitem_size[0], workitem_size[1], workitem_size[2]);

  // CL_DEVICE_MAX_WORK_GROUP_SIZE
  size_t workgroup_size;
  clGetDeviceInfo(device, CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(workgroup_size), &workgroup_size, NULL);
  printf("  CL_DEVICE_MAX_WORK_GROUP_SIZE:\t%u\n", workgroup_size);

  // CL_DEVICE_MAX_CLOCK_FREQUENCY
  cl_uint clock_frequency;
  clGetDeviceInfo(device, CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(clock_frequency), &clock_frequency, NULL);
  printf("  CL_DEVICE_MAX_CLOCK_FREQUENCY:\t%u MHz\n", clock_frequency);

  // CL_DEVICE_ADDRESS_BITS
  cl_uint addr_bits;
  clGetDeviceInfo(device, CL_DEVICE_ADDRESS_BITS, sizeof(addr_bits), &addr_bits, NULL);
  printf("  CL_DEVICE_ADDRESS_BITS:\t\t%u\n", addr_bits);

  // CL_DEVICE_MAX_MEM_ALLOC_SIZE
  cl_ulong max_mem_alloc_size;
  clGetDeviceInfo(device, CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(max_mem_alloc_size), &max_mem_alloc_size, NULL);
  printf("  CL_DEVICE_MAX_MEM_ALLOC_SIZE:\t\t%u MByte\n", (unsigned int)(max_mem_alloc_size / (1024 * 1024)));

  // CL_DEVICE_GLOBAL_MEM_SIZE
  cl_ulong mem_size;
  clGetDeviceInfo(device, CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(mem_size), &mem_size, NULL);
  printf("  CL_DEVICE_GLOBAL_MEM_SIZE:\t\t%u MByte\n", (unsigned int)(mem_size / (1024 * 1024)));

  // CL_DEVICE_ERROR_CORRECTION_SUPPORT
  cl_bool error_correction_support;
  clGetDeviceInfo(device, CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof(error_correction_support), &error_correction_support, NULL);
  printf("  CL_DEVICE_ERROR_CORRECTION_SUPPORT:\t%s\n", error_correction_support == CL_TRUE ? "yes" : "no");

  // CL_DEVICE_LOCAL_MEM_TYPE
  cl_device_local_mem_type local_mem_type;
  clGetDeviceInfo(device, CL_DEVICE_LOCAL_MEM_TYPE, sizeof(local_mem_type), &local_mem_type, NULL);
  printf("  CL_DEVICE_LOCAL_MEM_TYPE:\t\t%s\n", local_mem_type == 1 ? "local" : "global");

  // CL_DEVICE_LOCAL_MEM_SIZE
  clGetDeviceInfo(device, CL_DEVICE_LOCAL_MEM_SIZE, sizeof(mem_size), &mem_size, NULL);
  printf("  CL_DEVICE_LOCAL_MEM_SIZE:\t\t%u KByte\n", (unsigned int)(mem_size / 1024));

  // CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE
  clGetDeviceInfo(device, CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(mem_size), &mem_size, NULL);
  printf("  CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE:\t%u KByte\n", (unsigned int)(mem_size / 1024));

  // CL_DEVICE_QUEUE_PROPERTIES
  cl_command_queue_properties queue_properties;
  clGetDeviceInfo(device, CL_DEVICE_QUEUE_PROPERTIES, sizeof(queue_properties), &queue_properties, NULL);
  if( queue_properties & CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE )
    printf("  CL_DEVICE_QUEUE_PROPERTIES:\t\t%s\n", "CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE");
  if( queue_properties & CL_QUEUE_PROFILING_ENABLE )
    printf("  CL_DEVICE_QUEUE_PROPERTIES:\t\t%s\n", "CL_QUEUE_PROFILING_ENABLE");

  // CL_DEVICE_IMAGE_SUPPORT
  cl_bool image_support;
  clGetDeviceInfo(device, CL_DEVICE_IMAGE_SUPPORT, sizeof(image_support), &image_support, NULL);
  printf("  CL_DEVICE_IMAGE_SUPPORT:\t\t%u\n", image_support);

  // CL_DEVICE_MAX_READ_IMAGE_ARGS
  cl_uint max_read_image_args;
  clGetDeviceInfo(device, CL_DEVICE_MAX_READ_IMAGE_ARGS, sizeof(max_read_image_args), &max_read_image_args, NULL);
  printf("  CL_DEVICE_MAX_READ_IMAGE_ARGS:\t%u\n", max_read_image_args);

  // CL_DEVICE_MAX_WRITE_IMAGE_ARGS
  cl_uint max_write_image_args;
  clGetDeviceInfo(device, CL_DEVICE_MAX_WRITE_IMAGE_ARGS, sizeof(max_write_image_args), &max_write_image_args, NULL);
  printf("  CL_DEVICE_MAX_WRITE_IMAGE_ARGS:\t%u\n", max_write_image_args);

  // CL_DEVICE_IMAGE2D_MAX_WIDTH, CL_DEVICE_IMAGE2D_MAX_HEIGHT, CL_DEVICE_IMAGE3D_MAX_WIDTH, CL_DEVICE_IMAGE3D_MAX_HEIGHT, CL_DEVICE_IMAGE3D_MAX_DEPTH
  size_t szMaxDims[5];
  printf("\n  CL_DEVICE_IMAGE <dim>");
  clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_WIDTH, sizeof(size_t), &szMaxDims[0], NULL);
  printf("\t\t\t2D_MAX_WIDTH\t %u\n", szMaxDims[0]);
  clGetDeviceInfo(device, CL_DEVICE_IMAGE2D_MAX_HEIGHT, sizeof(size_t), &szMaxDims[1], NULL);
  printf("\t\t\t\t\t2D_MAX_HEIGHT\t %u\n", szMaxDims[1]);
  clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_WIDTH, sizeof(size_t), &szMaxDims[2], NULL);
  printf("\t\t\t\t\t3D_MAX_WIDTH\t %u\n", szMaxDims[2]);
  clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_HEIGHT, sizeof(size_t), &szMaxDims[3], NULL);
  printf("\t\t\t\t\t3D_MAX_HEIGHT\t %u\n", szMaxDims[3]);
  clGetDeviceInfo(device, CL_DEVICE_IMAGE3D_MAX_DEPTH, sizeof(size_t), &szMaxDims[4], NULL);
  printf("\t\t\t\t\t3D_MAX_DEPTH\t %u\n", szMaxDims[4]);

  // CL_DEVICE_PREFERRED_VECTOR_WIDTH_<type>
  printf("  CL_DEVICE_PREFERRED_VECTOR_WIDTH_<t>\t");
  cl_uint vec_width [6];
  clGetDeviceInfo(device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR, sizeof(cl_uint), &vec_width[0], NULL);
  clGetDeviceInfo(device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT, sizeof(cl_uint), &vec_width[1], NULL);
  clGetDeviceInfo(device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT, sizeof(cl_uint), &vec_width[2], NULL);
  clGetDeviceInfo(device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG, sizeof(cl_uint), &vec_width[3], NULL);
  clGetDeviceInfo(device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT, sizeof(cl_uint), &vec_width[4], NULL);
  clGetDeviceInfo(device, CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE, sizeof(cl_uint), &vec_width[5], NULL);
  printf("CHAR %u, SHORT %u, INT %u, FLOAT %u, DOUBLE %u\n\n\n",
   vec_width[0], vec_width[1], vec_width[2], vec_width[3], vec_width[4]);
}


int main(int argc, const char** argv) {
  // start logs
  printf("clDeviceQuery Starting...\n\n");
  bool bPassed = true;
  std::string sProfileString = "clDeviceQuery, Platform Name = ";

  // Get OpenCL platform ID for NVIDIA if avaiable, otherwise default
  char cBuffer[1024];
  cl_platform_id clSelectedPlatformID = NULL;
  cl_platform_id* clPlatformIDs;

  cl_uint num_platforms;
  cl_int ciErrNum = clGetPlatformIDs(0, NULL, &num_platforms);
  if (ciErrNum != CL_SUCCESS) {
    printf(" Error %i in clGetPlatformIDs Call!\n\n", ciErrNum);
    bPassed = false;
  } else {
    if (num_platforms == 0) {
      printf("No OpenCL platform found!\n\n");
      bPassed = false;
    } else {
      // if there's one platform or more, make space for ID's
      if ((clPlatformIDs = (cl_platform_id*)malloc(num_platforms * sizeof(cl_platform_id))) == NULL) {
	printf("Failed to allocate memory for cl_platform ID's!\n\n");
	bPassed = false;
      }

      printf("%d OpenCL Platforms found\n\n", num_platforms);
      // get platform info for each platform
      ciErrNum = clGetPlatformIDs (num_platforms, clPlatformIDs, NULL);
      for(cl_uint i = 0; i < num_platforms; ++i) {
	ciErrNum = clGetPlatformInfo (clPlatformIDs[i], CL_PLATFORM_NAME, 1024, &cBuffer, NULL);
	if(ciErrNum == CL_SUCCESS) {
	  clSelectedPlatformID = clPlatformIDs[i];
	  // Get OpenCL platform name and version
	  ciErrNum = clGetPlatformInfo (clSelectedPlatformID, CL_PLATFORM_NAME, sizeof(cBuffer), cBuffer, NULL);
	  if (ciErrNum == CL_SUCCESS) {
	    printf(" CL_PLATFORM_NAME: \t%s\n", cBuffer);
	    sProfileString += cBuffer;
	  } else {
	    printf(" Error %i in clGetPlatformInfo Call !!!\n\n", ciErrNum);
    bPassed = false;
  }
  sProfileString += ", Platform Version = ";

  ciErrNum = clGetPlatformInfo (clSelectedPlatformID, CL_PLATFORM_VERSION, sizeof(cBuffer), cBuffer, NULL);
  if (ciErrNum == CL_SUCCESS) {
    printf(" CL_PLATFORM_VERSION: \t%s\n", cBuffer);
    sProfileString += cBuffer;
  } else {
    printf(" Error %i in clGetPlatformInfo Call !!!\n\n", ciErrNum);
    bPassed = false;
  }

  // Log OpenCL SDK Version # (for convenience:  not specific to OpenCL)
  sProfileString += ", NumDevs = ";

  // Get and log OpenCL device info
  cl_uint ciDeviceCount;
  cl_device_id *devices;
  printf("OpenCL Device Info:\n\n");
  ciErrNum = clGetDeviceIDs (clSelectedPlatformID, CL_DEVICE_TYPE_ALL, 0, NULL, &ciDeviceCount);

  // check for 0 devices found or errors...
  if (ciDeviceCount == 0) {
    printf(" No devices found supporting OpenCL (return code %i)\n\n", ciErrNum);
    bPassed = false;
    sProfileString += "0";
  } else if (ciErrNum != CL_SUCCESS) {
    printf(" Error %i in clGetDeviceIDs call !!!\n\n", ciErrNum);
    bPassed = false;
  } else {
    // Get and log the OpenCL device ID's
    ciErrNum = clGetPlatformInfo (clSelectedPlatformID, CL_PLATFORM_NAME, sizeof(cBuffer), cBuffer, NULL);
    printf(" %u devices found supporting OpenCL on: %s\n\n", ciDeviceCount, cBuffer);
    char cTemp[2];
    sprintf(cTemp, "%u", ciDeviceCount);
    sProfileString += cTemp;
    if ((devices = (cl_device_id*)malloc(sizeof(cl_device_id) * ciDeviceCount)) == NULL) {
      printf(" Failed to allocate memory for devices !!!\n\n");
      bPassed = false;
    }
    ciErrNum = clGetDeviceIDs (clSelectedPlatformID, CL_DEVICE_TYPE_ALL, ciDeviceCount, devices, &ciDeviceCount);
    if (ciErrNum == CL_SUCCESS) {
      for(unsigned int i = 0; i < ciDeviceCount; ++i )  {
        printf(" ----------------------------------\n");
clGetDeviceInfo(devices[i], CL_DEVICE_NAME, sizeof(cBuffer), &cBuffer, NULL);
printf(" Device %s\n", cBuffer);
printf(" ---------------------------------\n");
clPrintDevInfo(devices[i]);
sProfileString += ", Device = ";
sProfileString += cBuffer;
      }
            } else {
      printf(" Error %i in clGetDeviceIDs call !!!\n\n", ciErrNum);
      bPassed = false;
    }
  }

  // masterlog info
  sProfileString += "\n";
  printf("%s", sProfileString.c_str());
}
free(clPlatformIDs);
      }
    }
  }

  // Log system info(for convenience:  not specific to OpenCL)
  printf( "\nSystem Info: \n\n");
  char timestr[255];
  time_t now = time(NULL);
  struct tm  *ts;

  ts = localtime(&now);

  strftime(timestr, 255, " %H:%M:%S, %m/%d/%Y",ts);

  // write time and date to logs
  printf(" Local Time/Date = %s\n", timestr);
  // write proc and OS info to logs
  // parse /proc/cpuinfo
  std::ifstream cpuinfo( "/proc/cpuinfo" ); // open the file in /proc
  std::string tmp;

  int cpu_num = 0;
  std::string cpu_name = "none";
  do {
    cpuinfo >> tmp;

    if( tmp == "processor" )
      cpu_num++;

    if( tmp == "name" ) {
      cpuinfo >> tmp; // skip :

      std::stringstream tmp_stream("");
      do {
	cpuinfo >> tmp;
	if (tmp != std::string("stepping")) {
	  tmp_stream << tmp.c_str() << " ";
	}

      }
      while (tmp != std::string("stepping"));

      cpu_name = tmp_stream.str();
    }
  }
  while ( (! cpuinfo.eof()) );

  // Linux version
  std::ifstream version( "/proc/version" );
  char versionstr[255];

  version.getline(versionstr, 255);

  printf(" CPU Name: %s\n # of CPU processors: %u\n %s\n\n\n",
	 cpu_name.c_str(),cpu_num,versionstr);

  // finish
  printf("TEST %s\n\n", bPassed ? "PASSED" : "FAILED !!!");
}

Now to compile this and run , bash $g++ -o clDeviceQuery -I/opt/intel/opencl-1.2-3.0.67279/include clDeviceQuery.cpp -lOpenCL && ./clDeviceQuery

If everything is alright , then you would be able to see a big log with a TEST PASSED printed at the bottom of it. If not, then you’ve messed up with your OpenCL driver installation or SDK installation(chances are very less).

Hope you get that up and running.

Every year Google runs a Summer of Code (GSoC) and as with every year, The Document Foundation is one of the major participating open source organizations. From a total of 91 proposals, 11 have been accepted this year and we …

My friend Andrew Updegrove wrote a surprising essay in his latest blog post about the irrelevance of open standards. More exactly his point, if I understood correctly, was that open standards were becoming irrelevant as a topic as everyone is using and relying on them, and the software industry can no longer afford to play the game of vendor lock-in towards customers, partners and competitors. If that’s Andy’s opinion I happen to disagree with it, but only partially. Let me explain.

Open Standards fading into oblivion as something that’s not interesting and yet so mundane because everyone would rely on them is somewhat of a good news I think. It is likely that some parts of the industry, such as cloud computing players, cannot afford to “invent” brand new proprietary platforms. Whatever you do, if this particular case is an example, is to design and develop a platform, an infrastructure or a service that is either OpenStack based, or at least fully capable of interfacing itself through Swift, AWS, Azure compatible or otherwise open APIs. While these are not all open standards, it’s a good thing: downstream players want to be compatible, but the upstream, major cloud technologies are open to some large extent as well as it is in their interest to be used and relied upon by the largest part of the market.

There are however some hiccups with vendor lock-in, in cloud computing or elsewhere. It just hasn’t disappeared. The lock-in still exists through proprietary or otherwise unimplementable file formats; through undocumented protocols and weak or non existent reversibility clauses. Vendor lock-in has not gone away, it has become more subtle by moving up the ladder. If your entire business processes are hosted and run by a cloud service provider there may be some good reasons for you to have made that choice; but the day the need for another provider or another platform is felt the real test will be to know if it is possible to back up your data and processes and rebuild them elsewhere and in a different way. That’s an area where open standards could really help and will play an increasing role. Another area where open standards are still contentious is multimedia: remember what happened to Mozilla in 2015 when they chose to embed proprietary, DRM-riddled codecs because of industry pressure.

Now Andrew suggests that the market is turning to FOSS the same way they first turned to open standards. True enough, FOSS has never been as popular as it is today, but I do not believe for a moment that it is because I.T. professionals or their clients understand what Free & Open Source Software is. That’s unfortunate of course, and we do need to keep in mind that open standards and FOSS, while being quite compatible, are two widely different things.

To come back to the original point, I believe something more incidental may explain his perception. From about 2006 to 2010, the world of open standards was full of exciting initiatives, global battles for market domination or liberation. Let’s mention a few of these: html5, microformats, RDF, ebXML and of course ODF, with the OOXML saga. That’s a lot in 4 to 5 years even for the tech industry. In some cases these standards have defined today’s state of the art, in others, they’re found anywhere on the Internet and the enterprise. After these years, open standards continued to grow of course; but the politics cooled down a bit and the bubble deflated.

Open standards are not going away, they still matter and I’m sure they will come back in the spotlight just like with pretty much everything in the I.T. industry. Look, we’re talking again about A.I. I can’t wait for the moment we’ll be bombarded by some paradigm shift in e-commerce or with the fat client as in, fat client and thin server in opposition to the thin client and the fat server where all the logic comes from the server. But I digress. Open standards help everyone who want to have a part to play in the game. Whether that standard ends up being used or not, replaced or opposed by another open standard is not what matters: that’s the life of standards. I’m confident we will see their importance being highlighted again for everyone soon or later.

We’re progressing with the organization of LibreOffice Conference 2016 in Brno. Italo Vignoli of The Document Foundation visited Brno last month, we showed him the venue and also places where we could hold a party, have a hacknight etc.

Recently we got a special discount for LIBOCon attendees from Vista Hotel. The hotel was recently renovated and is one of the closest hotels to the venue (15-minute walk or 2 stops by tram). The price we got is very good for the **** standard. You can find more info at the conference website and you can already book rooms.

We’re also looking for a low-cost option (most likely student dormitories) for those who don’t want to spend much money on accommodation and don’t require hotel comfort.

As the conference is getting closer we will publish more useful information for attendees on the conference website, stay tuned. We’ve also created a group chat for conference attendees on Telegram. You can ask us any questions there or chat with other attendees.

• Met with each other.
• Michael and Markus made presentations about following topics
• Solving arbitrary problems from a standing start - Real word engineering
• LibreOffice code structure
• LibreOffice core classes
•  Automated testing
•  Calc & Chart2
•  ODF and OOXML in LibreOffice
•  Data for LibreOffice developers

• Coding and coding :)

(NB: the opinions expressed in this post are entirely mine and do not necessarily represent the views of the Document Foundation.)

A few days ago Mozilla published a study by Simon Phipps about the possible choices of entities that could host the Thunderbird project. The finalists, for the lack of a better word, were the Software Freedom Conservancy, the Mozilla Foundation (working on different terms with the Thunderbird project) and the Document Foundation.
I’m not going to write about which one I think is the best for the Thunderbird project for two reasons: I think the question itself is quite complex and I do not claim to know the Thunderbird community and project that well. That being said, each possible choice seems very interesting and exciting for Thunderbird in my view.

Should the Document Foundation be considered as the final choice for Thunderbird, here’s my personal opinion on what challenges and opportunities await the Thunderbird project.

Let the contributors speak first

It sounds either like something obvious or someting that should have been already asked. To my knowledge, however, nobody has asked the community of contributors of Thunderbird if they have a clear opinion on the path to a (brighter) future. There’s more. Whatever the final choice of entity that will be made, Thunderbird should actually agree to that choice. And at least in the case of the Document Foundation, I believe it would only be logical that the members of the Document Foundation decide on whether it is a good idea for themselves.

One implied matter here is that the Thunderbird project should have a precise idea on who his actual contributors are, and from that data extract some notion on who can work on what, for how long and with what capability. What I’m trying to suggest here is that it is important to know where you’re starting from so that you can also tell what’s the more urgent tasks, technical or logistical.

Show me the code

When the LibreOffice project and the Document Foundation were started, we made sure code was available for download since the very first day. The reason we did this was twofold. We wanted to show we were credible from day one and we wanted to attract developers. Code is a great way to meet these two requirements: it reassures people and show potential developers you’re not all talk; in fact, you have something to show and potential itches to scratch. I do not suggest the Thunderbird project should have a fresh beta from day one. It should however have a public repository that shows some activity. Even better, a list of “low-hanging fruits”, issues or bugs that are relatively easy and fun to tackle would be a great way to attract developers.

The master of your ship

In the case of the Document Foundation, and to the best of my knowledge, the Thunderbird project will benefit from several key advantages: resources (both logistical and to some degree, financial), a very large autonomy (if not downright independence) and the ability and support to grow as a project and a community. What the Document Foundation will not provide, should it become the final choice of the Mozilla foundation as the next home for Thunderbird is an important point I fear many people have overlooked or have not understood.

• The Document Foundation has no developers to offer, no contributor to be produced by magical means. Being a project of the Document Foundation allows you to be part of it as individual contributors and to set your project free. But neither money, nor code will start to rain on Thunderbird as a result. Signing up with the Document Foundation implies the Thunderbird project realizes hard work lies ahead.
• The developers of the LibreOffce and the Document Liberation projects will not all of a sudden show up, fix your small XPCOM and XUL inconveniences and work on the remaining tasks for the project. The Thunderbird project, hopefully gaining developers in the transition towards the Document Foundation, will have to deal with its own technical challenges and opportunities on its own.
• The Document Foundation will not dictate the roadmap and technological options for Thunderbird. Of course, I’m rather confident several LibreOffice developers can think of possible opportunities for technical cooperation and even some sort of loose integration between LibreOffice and Thunderbird. But that’s the extent of it: if there are enough developers interested from both sides, things will start happening. If not… it won’t happen, and nobody should feel sorry about it.

Opportunities

If you have been reading this post until this very point you may be wondering whether I would actually like to see Thunderbird join the Document Foundation. Of course I would be very happy to see Thunderbird join us and transform itself into a strong, community-led project that will put my previous posts about why I don’t like to use it to rest and to shame. But I also happen to think that it is crucially important for everyone involved (from Thunderbird to the Document Foundation to the Thunderbird users themselves) to get it right from the start. The best home for Thunderbird is the one that will let it grow into a strong community of contributors. In order to do that the most important part does not come with the host structure but from within Thunderbird itself. I strongly believe that the Document Foundation is ideally positioned to be that home. Once the contributors are active, the technical debt is being effectively addressed, then I am confident that the much awaited synergies will start to show: document management, email editors and outliners, common packaging, LibreOffice OnLine and even an online Thunderbird continuum with their desktop versions, Android ports…

Seriously, the road ahead is bright and clear. But until we reach that point, there are some real challenges to overcome. I wish the best to Thunderbird, sincerely, whatever will be the decision of Mozilla.

One of the benefits of being a student is getting Office 365. I also have Office 2010 so that leaves me with bot Office 2010 and 2016.

Recently I tried to save a Excel file in OOXML Strict and confront my 2010 edition Excel with it.

The hilarious thing is the following image:

So my Office 2010 should be able to open the Strict OOXml without problems (with this some month old file it actually does). But why is Microsoft frightening the enduser? The best thing is the linked page (from the dialog in the first picture) “Support for Office 2003 has ended“. If you need the converter, it can be found here. UPDATE:Removed link as it broke my Office 2016!!!!

And finally the sentence you were waiting for: Waaait, Office 2010 can open the OOXML strict standard, but not the file saved with Office 2016 with “OOXML strict”. So the “OOXML strict” is not Standard (or there is a biiig bug in Office 2010, which prevents interoperability)…..

Our Hoster Manitu is currently experiencing a DoS attack on its infrastructure. They are working on measures to fight the attack. This might affect the availability of many of our services.

Today I would like to focus on a quite interesting project, even though it is rarely spoken of: The Document Liberation Project. The Document Liberation Project is LibreOffice’s sister project and is hosted inside the Document Foundation; it keeps its own distinct goals and ecosystem however. We often think of it as being overly technical to explain, as the project does not provide binaries everyone may download and install on a computer. Let’s describe in a few words what it does. The Document Liberation project aims at developing filters handling various file formats. The output of the project is then reused inside LibreOffice as well as in other Free Software such as (but not limited to) Inkscape, Abiword, etc.

Many people have files and documents that are sitting somewhere on their hard drives and that were first generated by an ancient office suite, word processor or spreadsheet application. Most of these file formats were never publicly documented. As a result, people experience vendor lock-in as they are unable to convert them in a stable, supported and open file format they can actually use. In order to solve this conundrum the Document Liberation project has a set of export filters that convert files to ODF, epub and even Abiword format. Its crownjewel, so to speak, is the set of import filters it has been collecting over the years and that it has improved. Those filters range from MS Publisher files to Clarisworks and Apple Keynote and also have many rarely used file formats. Let’s take a look at the list mentioned on the project’s website:

libwpd
Corel WordPerfect import library.
libwpg
Corel WordPerfect Graphics import library.
libwps
Microsoft Works import library.
libmwaw
A library for import of many legacy Mac document formats.
libabw
AbiWord import library.
libcdr
Corel Draw import library.
libmspub
Microsoft Publisher import library.
libvisio
Microsoft Visio import library.
libetonyek
Apple Keynote/Pages/Numbers import library.
libfreehand
Aldus/Macromedia/Adobe FreeHand import library.
libe-book
A library for import of many e-book formats.
libpagemaker
Adobe PageMaker import library.

This list is impressive and keeps growing. One may also notice the usefulness of the project for digital artists and designers. You can help the project in three ways:
* help developing these filters and libraries
* help documenting the formats the project tries to manage
* submit test documents and assess how effective the filters are in real life.

You may of course donate to the Document Foundation as well. The Document Liberation project matters a lot. It matters for many different people and for the ecosystem of desktop software relying on these files, from office suites to graphical design tool and document processors. If you feel like you could help, do not hesitate one bit, your contribution will be much appreciated and you will help liberating the world, one document at a time.