Recently, an OOo blog published a proposal for a new interface design.

A short glimpse at a screenshot reveals: It is not so new as it seems. On the contrary, it looks like it is directly ripped off of Microsofts Office 2007, which sported the new 'ribbon' design.

My question about this is: Why?

Copying

Copying from each other seems to be endemic in the IT industry. Simply said, just as Microsoft lifted its Windows UI from the Mac UI, the Linux UI was lifted from the Windows UI. Designing a UI is a very hard task, and most programmers are definitely not good UI designers (and vice versa). Unfortunately there are also a lot more programmers than UI designers.

So the newest chapter might now that OOo lifts the ribbon UI from MS Office (and even that might be lifted of from a Software called eSuite)

But copying implies the danger that only the superficial things are indeed copied (e.g. as it happened when MS copied Windows from the Macintosh System Software) with the potential of creating errors through not understanding the original concept, never having done the fundamental design work leading to the original decisions. (This fundamental work was indeed done, when Apple bought IP from Xerox to infuse their UI research)
Now apply this to every copying process and you get the current state of a big part of the IT industry. (And not just the UI part, but that is the most obvious one).

Now why OpenOffice? I think this is twofold: For once, it seems OOo wants to appeal to MS Office users, so offering them a familiar UI with a seemingly better and cheaper software should do the trick. The other cause may - like I said above - there are not enough good UI designers.

Regarding UI and appealing to Office users, I think John Gruber from Daring Fireball just nails it in his article Putting What Little We Actually Know About Chrome OS Into Context:

But that’s not how you get people to switch to a new product. People won’t switch to something that’s just a little bit better than what they’re used to. People switch when they see something that is way better, holy shit better, wow, this is like ten times better.

The original comment was about Windows vs Linux/KDE/Gnome, but it perfectly fits into MS Office vs. OOo.

Now obviously, even a ribbon enabled version of OOo won't be ten times better than MS Office. It is cheaper and - what makes it most attractive - is available on platforms MS Office is not available for. (Which indeed makes it infinely better on these platforms)

The ribbon problem

Crying that you don't like the ribbon does not make it easier for the OOo guys to invent a better way of interacting with their software.

So what paradigms for Office Software exist?

Complementing the Menubar, more and more Buttons are added to the document window to allow easier access to lots of functions. That goes from no Buttons to just a few to far too many.

This system is used by a lot of software, including OOo today.

To cope with the ever increasing number, Microsoft introduced the ribbon which should bring order to the myriad of buttons. Notice, it did not decrease the number of buttons, it just put dem into stacks, and the user now chooses which stack to show. Thereby always hiding some buttons while exposing others. And introducing the problem of switching the button-stacks, consequently increasing the number of clicks one has to do to reach a certain function. It is now search (right ribbon stack), click, search (right button), click in the worst case. The old case at least benefitted from a spacial interface, i.e. after some time, the user grew accustomed to the position of the buttons, hitting them faster.

The real problem of too many buttons is ignored.

But does 'stacks of functions' neatly grouped not sound strikingly familiar? Yes, there always was something called the menubar which already offered this functionality. Being not always visible (like most of the ribbon stack) the menus have lots of place for speaking names instead of tiny icons. So introducing the ribbon just rearranged functionality a little.

The myriad of buttons is surely the motivation for the Apple Cocoa API to just offer one button bar. So additional functionality has to be separated into more dedicated screen elements, usually a palette window. While this is conceptually similar to a ribbon based interface it still allows buttons which are always visible, therefore spacial, and it allows you to display multiple palettes, so that you could customize the workspace to your needs. (Albeit introducing more complexity - just look at Adobe software, which however is designed for the advanced user)

The usual compromise seems to be a button bar with only prominent features (so no new, save, open, cut, copy, paste), and a context sensitive 'formatting palette'. Everything else is then added as needed, or a standard configuration is shown.

While I do not consider this totally superior, it has the added bonus of at least some spaciality and a lot more functionality.

Potential for imrovement would be really know what the user is doing and then automatically showing functionality only when it is really needed - without becoming obnoxious like the attempt Microsoft did with the Clippy assistant.

From a UI perspective less is definitely more, albeit not directly recognizeable.
So hopefully the OOo designers will rethink their current prototype.