Nemo is not quite dead yet. It’s been a long time since the last release, as I’ve been super busy with external contracting work at IOLA so I havn’t really had time to work that much on Nemo. There are some interesting things coming up in the Nemo space in the future, so far I can’t say much about what they are since they are still quite a bit up in the air, but be sure that Nemo is not dead yet 🙂
Category: nemo
I’ve just booked tickets and will be attending the Maemo Summit. I’ll be there for mostly for the Desktop Search Hackfest representing Nemo.
Release time! Nemo 0.2.3 released
Had some nice crasher fixes in svn for a while so I thought I would do a release of Nemo. The release is very minor, but the changes should be rather welcome for everyone 🙂
I made a new release of Nemo 0.2.2 today. It has some nice memory usage improvements and indexing fixes. Plus day view got pagination so that it can handle large number of files on a single day (like an svn update) gracefully. Upgrading is highly recommended.
We had this problem in Nemo 0.2.0 that it would use quite a lot of cpu while it was indexing. I kind of knew this could happen but hoped that a transaction optimization to the database could improve the performance enough to make this problem irrelevant. Sadly it did not. The indexing code works by running an event loop in a single thread and then having two queues, one for tasks that needs to be completed fast and one for background tasks. Each of the queues are basically just a list of function pointers that is popped when a new task need to run.
The nice property of the indexing code is that it would put each task into simple function that one could read from start to end. The same property that is usually associated with programming using threads compared to programming using events where the code has to be broken into several parts. I feared that I had to go the event way and break the indexing up into smaller functions and do a lot of tedious book keeping to make sure the code could be resumed.
After thinking about the problem for a little while it dawned on me that this is the a perfect case for yielding. Yielding allows you to suspend the execution of a function and return immediately which is perfect for this problem since the runtime will automatically do all the book keeping for you. Another really nice thing is that it turns out that converting the code was extremely simple.
Instead of storing simple function pointer in the queue, we just store an object of type IEnumerable<bool> which will wrap the function and make sure we can call it multiple times. When the Enumerable is called it will keep returning true as long as there’s still work to do in the function wrapped. So the function could just return false and it would work the exact same way as it did before. So one can think of the IEnumerable as a sort of higher order function.
So we just need to wrap the normal functions with the following code:
private IEnumeratorTurnEnumerableIntoEnumerator(IEnumerable enumerable) { IEnumerator < bool > t = enumerable.GetEnumerator(); while (t.MoveNext()) { yield return t.Current; } // make compiler happy yield break; }
And make the function wrapped return IEnumerable
Nemo 0.2.1 released
Did the release of nemo 0.2.1 today. The release is the result of a large amount of massaging of the nemo code to use less cpu and memory (a garbage collector suddently makes these interlinked in a new one is not usually familiar with when coming from a language like C++). Then some profiling and massaging of GTK# which is sadly still not 100% ready for prime time. And finally some poking at mono code for which I’m not ready with a patch yet (tomorrow it will be), but I’ve improved the performance of the inotify backend of the filesystemwatcher by quite a bit especially when watching a large number of directories.
Long time since I’ve blogged about Nemo. Since the initial release a little over a month ago we have had two major releases, the first one a bugfix release to fix some of the defects reported and the 0.2 release which adds support for beagle through Xesam and lots of other nice enhancements like pagination on the search results popup and better indexing performance. The software is still fresh but I consider this to be the first release that I would feel comfortable recommending to a stranger 🙂
I’m very pleased that I can now finally lift the curtain and show what I’ve been spending most of my time working at iola on.
It’s been a long ride, but now the alpha release is finally ready for public consumption 🙂