Me and Gustavo Padovan are presenting a talk about BlueZ at a series of seminars about free software hosted at University of Campinas (Unicamp). If you’re nearby come to join us 16h at CB01 today. We gonna give a brief overview of bluetooth and BlueZ, talk about our contributions to the BlueZ project, and show a little about how to use the BlueZ API inside your applications or as an end-user.

If you’re far away from Campinas, you can at least take a look at the slides: BlueZ talk

Been at the mentor summit for the first time, and it was even exceeding my high expectations. Awe-some. If there’s another event that pulls together so many friendly high-profile FLOSS people, I’d like to know immediately.

Many kudos to Google for the event, and warthog9 for the nice group pic!

With the mentor summit coming up, it’s high time to wrap up this year’s Google Summer of Code for ooo-build. We started the term with 6 students, of which one was sadly missing in action right from the beginning (to set the record straight, he returned all funds).

All participants initially had to fight with OOo’s inherent complexity; I can only stress the importance of getting used to build system, installation & debugging peculiarities before the actual coding starts.

Progress until midterm was good to excellent, except for one case, where we had to make the very hard decision whether to continue with a student showing insufficient results – in the end, the agreement was to drop him, pretty much according to all best practices and lessons learned from other organisations. What I find most encouraging, and open-minded, is the fact that he’s now returning to OOo, and even bringing a few other students from his university for a joint project. Welcome back, Jon!

Which leaves us with a total of four completed projects:

• Cross-building OOo for win32 (Jesus Corrius, the code (basically all crosswin32-prefixed patches))
• Impress slide layout rework (Dona Hertel, the code)
• Writer document comparison (Tzvetelina Tzeneva, the code)
• Writer document navigation buttons (Maja Djordjevic, the code)

For the last two, let me just reference Tzvetelina’s and Maja’s respective blog postings; I couldn’t possibly explain and advertise it better.

The idea for the cross-building stems from the fact that compiling OOo on win32 is dog slow. With OOo consisting of some 90% c++, compilation is highly i/o-intensive, with an access pattern that apparently makes the Linux buffer cache shine, and the Windows one fall flat on its face. Additionally, of course you’d free people from buying and relying on proprietary software. Additionally, having something cross-buildable usually makes a project’s build system cleaner and more orthogonal.

With the Impress slide layout project, the aim was to get rid of the many hard-coded places where slide layout kinds were handled, following the paradigm of having pure data – the general layout – in a data structure, and not implicitely in code. Of course, an extra benefit is that changing or adding layouts now no longer needs re-compilation of OOo. Specifically, Impress now loads an autolayout configuration file on startup, and exposes the necessary data structures via OOo’s component model to the lower-level subsystems, for import and export.

This was my second GSoC term as a mentor, and my first one as an organisation admin. I’m more than happy with the results; our students did really well, and I hope we’ll see continued contribution from them over time. I also wish to thank my fellow mentors for their time and enthusiasm, and of course Google for making all of this possible in the first place!

Finally, there’ll be a panel presentation of the GSoC results at the annual OpenOffice.org conference; we’ll hopefully manage to get most of the students and mentors there. Will keep you posted.

University of Moratuwa has done it again!!! It has emerged as the best university in ‘Software Engineering’ in the world in a highly competitive global competition, held annually. “Free and Open Source Software (FOSS)” which also goes by the name Google Summer of Code is a competition that tests the creativity, talent, abilities and performance of students.

“This annual competition commenced in 2005. In the last four years the University of Moratuwa has been ranked the No.1 University among 1193 Universities worldwide and have won over twice the number of awards than second placed University of Toronto, Canada,” Vice Chancellor of the Moratuwa University Prof. Malik Ranasighe said. Read More.

GSOC 09

Alright this is very old news (One month old). I’ve been a bit busy to make a blogpost. I passed the final GSOC evaluations along with the 7 others of the NUIGroup organizations. It feels great to be one of the several hundred students to complete the program. I really thank my mentors, my elder brother, nuigroup organization and all others who helped me in completing this. Google, thanks for organizing such a great program. This has definitely given me a new way to look at opensource technologies and its organizations.

Right now, I’m waiting for my visa to head up to NUITEQ Sweden. I will be a intern at that company for next three months. “Great people, great envirnoment to work in”, is what i felt everytime I heard about NUITEQ from other people who worked/works there. I’m really excited to be working with them. Thanks Harry for giving me a opportunity to be working with you and your team . There is even a coffee mug waiting for me there . How cool is that…

NUITeq Coffee Mug

University of Moratuwa has been able to top the Google Summer of Code program, yet again. With 22 participating students university of Moratuwa was far ahead from the second place, University of Campinas Brazil which had 12 participating students. I’m glad i was a part of this success. Here are some stats of GSOC 2009.

Google Summer of Code (TM) T-Shirt has arrived!  I had the pleasure of being a mentor on the OpenMRS Data Integrety Module project, coded by Nimantha.  The project was a great success.

OpenMRS Google Summer of Code(TM) 2009

Google has officially announced the wrap up of its 5th “Google Summer Of Code“. This year about 1000 students from 60 countries participated and were placed under 2000 mentors. About 85% of them (comprising of 150 projects) cleared the final evaluation,which is 2% more than previous year. More information on these projects are expected to be available in the coming  days , through Google’s official blog.

Additional Readings :

• GSOC 2009 official site
• Five years of introducing students to open source
• List of all student GSOC  2009 projects

I’m very pleased to report that our GSOC students, Andrei, Jose, Olli, Mihai and Alberto, have passed their final evaluations with flying colours! Congratulations everyone, and thanks, as always, to our mentors.

We’re currently setting up test sites for several of the projects and evaluating the code for possible inclusion in HEAD.

Please see GSOC/2009 for test site links plus links to developer blogs in which each of our students have written a summary of their summer of code working with Moodle.

So GSoC ended already, as most of you already know. I haven’t been blogging as much as I would like, and I didn’t achieve to finish on time everything I wanted, but that’s not a defeat, only a delay – I will continue working on this bookmarks system until it can get merged into trunk. And then I’ll fix incomintheg related bug reports =).

So the state of the art is: we’ve got an akonadi resource for konqueror bookmarks which stores the bookmarks in nepomuk. We’ve got a bookmarks organizer, and we’ve got a bookmarks menu integrated in konqueror. The new location bar is however not finished yet, but that will be fixed within days.

A lot has changed since last report. I’ll try to explain here what’s the base structure of the new classes and what I’ve been doing, mainly related to the location bar, and why I followed that design decisions.

KCompletion

The current konqueror location bar uses a KCompletion class for autocompletion, which is mainly handled by KLineEdit. But how does it work? Let’s use a simple example. Imagine you are developing kmail’s new email dialog. For the line in which the user enters the destination email address, you could use a KLineEdit, but in order to easy the task of the user, you could use autocompletion like this:


KLineEdit* destinationLineEdit = new KLineEdit(this);
...
KCompletion completion;
completion.addItem("tigerwoods@fortune.com");
completion.addItem("billgates@microsoft.com");
...
destinationLineEdit->setCompletionObject(completion);


You could of course get the list of items to add to the completion object from the address list too . If you were developing instead the location bar for dolphin, you would like to have directories listed while the user is typing. Instead of adding and removing items manually yourself to the completion each time the user types, you can use a KUrlCompletion object that does that automatically.

But for konqueror location bar we have a problem: it needs to be able to use kurlcompletion for completing directories, but it also needs to complete from bookmarks and history. We need to work with multiple completion objects at once even though KLineEdit and similar classes can work only with one. Also, we need to do more complex completion A normal KCompletion object contains a list of strings and matches what you type with those, but for having an amazing location bar we need more power: if I type “work” and I have a bookmark tagged “work”, I want it to show up in the completion list even if its URL doesn’t contain the word “work” at all. And that’s only the beginning. I want to be able to set an order of the completed items depending on the relevance and type of the items, and more..

Enter Qt Model-views

I need to confess that I love Qt model-views classes. QAbstractItemModel, QAbstractItemView, QAbstractProxyModel, QSortFilterProxyModel, QTreeView.. They provide an standard convinient and flexible way to manage and display almost any kind of collections. Even collections of completed items. Actually, the completed items popup is in reality a QListWidget, which displays a model associated with the completion object..

But that is an internal model which KLineEdit doesn’t let me change. So the question that follows is.. why not use directly my own custom item models instead of a KCompletion object? And that’s what I did, even if it required a lot of work to be done.

First of all, I tried to outline in paper the master plan. What classes needed to be created for everything to work fine. Then I wrote step by step what needed to be done before what. Then I started following those steps one by one and it worked!

Places all over the.. place

The plan was that the location bar autocompletes places. A place could be:

• a history entry from history entries model
• a bookmark from bookmarks model
• an url from a kurlcompletion model

I had already a bookmarks model and konqueror already has an history entries model, but I had no kurlcompletion model. I looked at the code of the KUrlCompletion class I decided that I didn’t want to rewrite it.. so I simply created a KCompletionModel which acts as a proxy and converts a KCompletion object in a QAbstractItemModel. So to create a url completion model, I do:

KUrlCompletion* urlCompletion = new KUrlCompletion();
KCompletionModel* urlCompletionModel = new KCompletionModel();
urlCompletionModel->setCompletion(urlCompletion);


To do a completion, I connect the urlCompletion to the textChanged(QString) signal from the lineedit. And the completion objects reflects the changes which in turn instantly appear in the model. It’s not the best solution but hey it works.

Also, another problem was that the completion object of KLineEdit would be replaced by a model, not three. But now as you see I have again multiple completion objects, so what was the solution? creating an aggregated model created out of multiple models. It works like this:


KAggregatedModel* aggregatedModel = new KAggregatedModel(this);
aggregatedModel->addSourceModel(bookmarksModel);
aggregatedModel->addSourceModel(historyEntriesModel);
aggregatedModel->addSourceModel(urlCompletionModel);


Now, those who know how an item model works will probably have a lot of questions about that. For example one could be.. Do all those models need to share the same columns? The answer is no. The aggregated model I created is quite simplistic in the way it works:

• It assumes the source models have only one level of childrens.
• It only shows one column, which is the default display column (sourceIndex.data(role)).
• It shows the list of items as a list, showing first the items from the first item model, then the ones from the second, etc.

Places Manager

So far we have an aggregated model with completed urls, unfiltered bookmarks and unfiltered history entries. That’s yet not complete from being the amazing completer model. What we need to do is the amazing filtering and sorting. That’s done by the final completion model, the master of places..

It’s called PlacesProxyModel and inherits QSortFilterProxyModel. It takes a QAbstractIteModel and takes the Konqueror::PlaceUrlRole for each index, gets the URL, and obtains the corresponding Konqueror::Place for it. Then, knowing already all the available information for that place, tries to match it against the query the user entered in the lineedit and sets its relevance for sorting purposes. It also filters out duplicated entries. Quite an achievement, but how does all that work again?

First off, all previous models (url completion, bookmarks and history entries models) report their items to a Places Manager which keeps track of them and contains a Place for each relevant url. So for example, if the user has bookmark for http://www.kde.org and it’s been visited yesterday, there’s a place in the places manager with the information from both the bookmark and the history entry.

All those models also support obtaining the url related to each item by using the Konqueror::PlaceUrlRole. The aggregated model proxies calls to retrieve data from any role, including that. So in the end the information can be retrieved by the places proxy model. Then an algorithm that takes into account the number of visits, the last visit, if the user-written string matched the place’s url, title or tags, etc sets the relevance of the items in the proxy model.

The road to the location bar

The new location bar inherits from the modified KLineEdit which uses a QAbstractItemModel for completion, which I have named KLineEditView. An amazing location bar needs to be able to show an star that can be clicked to add/remove a bookmark, and the autocompletion needs to show for each place shown if it’s bookmarked, its tags, etc. Contextual information.

State of the art

What has been done? All the previous things I have mentioned are working. They can always improve, but the code is already there. The location bar widget is the last thing I started to write so it’s not finished: it has already plugins support so that new icons/sub-widgets can be shown inside the location bar. Now I need to write the plugin to let the user bookmark the current location, and I also need to write the CompletionPlaceDelegate to have a properly eye-candied completion list. And I’ll do it shortly.

Future and end

Unfortunately, a lot of things need to be done before this new bookmarks system ends up in konqueror trunk. Revamping such an integral part of Konqi is not a simple task. We also want to be sure that when the replacements comes into play the user doesn’t have to suffer it but to enjoy it instead, so I need to find fix and all the regressions. I need to write documentation and test cases too. I honestly don’t really know when the job will be done but I know I’ll continue working on it.

I want to thank specially my mentor David Faure for the support, for giving me a thumbs up even if I didn’t finish on time everything I wrote in my gsoc propossal. You rock david!

This is post has been too large I admit, so I think I’ll stop here . If you read everything yay you’ve got too much free time so go and do something more useful!

My Coding for GSoC finished last week and I completed the final report on Saturday. The final report is not yet in code base but will be there tonight. This version will be submitted to Google as part of the requirements of GSoC. I will continue working on this project as part of my work in COSTAR lab. I may keep updating this blog. So I am going to change the name of the blog as the first step.

The Google Summer of Code is over and the first version of the keyring library was released last week by Kang at PyPI.

How Keyring works, the big picture

This library implements a simple plugin system. Each plugin has to implement a set of methods described in an abstract class and can wrap any underlying Keyring system. We called those plugins “backends“. The nice thing about it is that you can implement your own custom backend and make it available through the Keyring configuration file.

Kang has coded various Keyring backends in C and C++ extensions, for KWallet, Keychain, and Gnome. We also have added a Keyring implementation that uses the Win32Crypto API so windows users can use the lib.

When the Keyring lib is used, all declared plugins, whether they are provided by the lib itself or by a third party package, will be loaded. Then they will be asked a simple question:

“Can you run in this environment ?”

The backend can answer one of these:

• “Yes, I could work in this environment”
• “No, I can’t”
• “Yes and you should use me  !”

The library filters out backends that can’t work on the target, sort the remaining ones, and get one of the best backend. This doesn’t happens of course if you explicitely define which backend you want to use, which is possible.

What’s next

Keyring 0.1 is out and there will probably be 1 or 2 releases to stabilize the code.

The next steps will be :

• to use it in Distutils, with a soft dependency : Distutils will let you use it through configuration if it detects Keyring is installed.
• to promote its usage and in particular see if projects like Mercurial could use it
• to work on a PEP for its integration in Python stdlib, in the getpass module

I have finished google summer of code. Now’s just the waiting to see if they’re going to pay me.

Man. Let the parting be joyful and may I never return.

Pencils down declared for GSoC 2009 and here I am to pen down my thoughts/experience. At the start of the project I had visualized it something different but at the end it turned up as much better an application. All thanks to Nagarjuna sir & his great ideas. Since beginning he has been inspiring me to use org-mode features & seriously at the end I feel its the beauty of org-mode that makes gnowsys-mode so simple and yet so pretty.

“gnowsys-mode” is an extension package for Emacs,  a text editor.  Motivation of the project is collaborative knowledge networking & organization. As a major-mode for Emacs, it dispels the common axiom, that collaborative authoring can be done only through web applications but not from a text editor.

This dialect of knowledge networking offers a prospect of robustness to the shared data, applying GNOWSYS rules of inferences to it. It provides a plethora which lets you semantically conceptualize information/knowledge with the ease of a traditional text editor.  Peers using gnowsys-mode may agree on a shared conceptualization of a knowledge domain in the form of ontology, and collectively maintain it over time. Versioning feature of GNOWSYS allows change tracking by creating snapshots & maintaining metadata details of each snapshot.

Adhering to the concepts of semantic web, GNOWSYS allows to convert the knowledge node in RDF tripples. So any knowledge node being created or viewed in gnowsys-mode can also be viewed in respective RDF N3 format. It also enables to visualize the knowledge networks graphically, in the form of concept map.

It is implemented on top of Org mode, which helps to give a formal structure to knowledge network in the form of drawers and also makes it possible to navigate through the network in the text buffer using the node links.

Though Emacs is well known as an editor, gnowsys-mode doesn’t restrict you to work on your desktop but also gives you the freedom to work on a remote GNOWSYS server. We have hosted a server http://sandboxat.gnowledge.org , which is default URL prompted to establish connection with. This is created for the testing purpose, so feel free to connect to it and work around. Or install GNOWSYS on your machine using installer provided here.

To get a live demo on how to use gnowsys-mode, watch the videos provided here.

Get gnowsys-mode from svn repository using:

svn co svn://svn.sv.gnu.org/gnowsys/gnowsys-mode

After playing around with a couple of register allocation algorithms I implemented Furthest First heuristic. This is a simple and efficient Local Register Allocation algorithm. “Local” here means we are working on a basic block of code, no jumps, no loops, etc. This is exactly the situation in the current version of IDISA.

Furthest First analyses the code line by line and allocates registers. Whenever there is not enough register to accommodate all live variables the one that will be used further in the program will be spilled. The rationale behind it is easy to understand and can be stated in different ways. It gives you the longest possible interval in which one register is free. The chances are that by then register pressure has reduced.  Actually if you want to write a register allocation algorithm by yourself, without looking at a textbook or paper, it is quite likely that you end up using Furthest First.

Earlier I wrote about this question: Should register allocation be done on three address code or on two address code. I have always done it  on three address code. Now I am almost sure that this is wrong. It should be done on two address code. Right now, in my register allocation algorithm I have to consider that the code will later be transformed to two address code.

I did some test on the current code.  Still more test is needed.