Source: My Visions
OpenOffice.org (OO.o) developer Kay Ramme has just posted his visions for the future OO.o. He outlines several major points that will really help bring OO.o into the future. Following is a
Make all of OOo MVC (Model View Controller)
MVC is a long standing application architecture that really helps separate the user interface from the code and data. Major benefits of this approach are a more flexible GUI as it is not tied to the underlying code and the ability to restructure the data without affecting the presentation. The MVC architecture has been around for quite a while and is generally accepted to be a good way to structure your application. This will make OO.o more robust and will greatly help with maintaining OO.o and reducing potential for bugs. Ruby on Rails is a popular example of how a strict MVC structure for you code will benefit your application.
See: Wikipedia: MVC
Unified application with just different work approaches
Currently OO.o is split into a few different application, Draw, Writer, Calc, Base, Impress, etc. These are all the same binary but they show significantly different interfaces and functionality. This vision talks about truly unifying the applications so that no functionality is duplicated and there is less ways to do things. For example, currently in Writer there is a table feature that is completely different from the spreadsheet functionality of Calc. What would be ideal is to unify this functionality so that tables in writer & impress are the same as the spreadsheet in Calc. There will have to additional features added to the spreadsheet functionality to make it a suitable replacement to the table function but this will help unify the application and will reduce code and then potential for future problems. Also this will make the application simpler to use as there will be only one way to interact/create a spreadsheet/table.
OO.o's main competitor Microsoft Office is slowly working on this and has made some improvements in the latest Office 2007, but still does not have this. Koffice the KDE office project is working on this exact idea as the basis for Koffice 2 and could become a major alternative to OO.o in the free software arena.
Event driven architecture
This vision also requires a major architectural shift but will make for a much more robust code base. Event driven architecture is basically changing the code to make it respond only to events. These are usually user events (clicking a button, typing, scrolling the mouse wheel). The alternative to this is batch or flow driven programming where the programmer controls the flow of the application. What this means for the user is a much more reactive application that responds to user input. All interactive application have some of this functionality but by pushing it to the next level OO.o will be much more responsive and user friendly.
See: Wikipedia: Event Driven Architecture
Common threading model
This vision looks to have a common threading model throughout the OO.o code. There is an ongoing push to make all code threaded to help with utilizing new multi-core processors and OO.o is working towards this. By using a common threading architecture you reduce code and bugs by reusing the same functionality throughout the code.
See: OO.o: Uno Threading Model
Declarative Language GUI
This vision relates to the MVC as it requires the adoption of a language to describe the user interface. This allows the presentation to be separated from the code and allows for more flexible UI creation and easier changes/themeing/customizing of the UI. Another benefit of this is that this language is easier to understand then the C++ that OO.o is mainly programmed in so this could allow for people who have trouble with the complicated code base to be able to contribute better to the GUI. In other applications this separation has allowed graphic artists to easier customize the interface and make a much slicker product.
One of the best examples of this is the Firefox/Thunderbird/Sunbird/Sea Monkey programs from Mozilla. All of these applications use a language called XUL to describe the UI. This allows all theses applications to run on a very similar code base (soon to be more the same through the use of xulrunner) with most of the differences in the XUL interface code. All of these applications allow easy customization through the use of extensions and add-ons.
See: Wikipedia: User interface markup language
Improve the Build System
OO.o has the reputation of being hard to compile, and from many reports this is very true. It's immense code base and complicated structure make it one of the largest projects within the open source community. But this reputation also hurts adoption and contribution by external developers as they can have problems modifying the code and then compiling their changes. This vision is looking to make the build process much saner and only require GNU make without any external dependencies (for the building process). This vision also calls for saner output form the compiling process to help with debugging the build process.
So that is one developers view for the future of OO.o. Please check out the original post for more information and the included links. OO.o is a great office suite and bringing ideas and visions such as these to the public eye can only benefit the project as a whole.
Monday, July 23, 2007
Source: My Visions