monkeyiq

ODF/C++ Job seeking; br; see you at LCA...

2012-01-14T03:36:00.000-08:00

If anyone knows of ODF(+RDF?), Qt, KDE, C++ jobs floating around I'm headed back into that market. It would be fabulous to continue to hack on FOSS code ;)

In other news, if you are at LCA this week then you might like to drop by to see Martin and my talk on Abiword and RDF stuff.

RDF, Abiword and Relations

2012-01-08T18:18:00.000-08:00

Abiword now has growing GUI support for editing RDF in ODF documents. Much of this support compliments what is available in Calligra for RDF handling. There are some areas where Calligra has more features and some areas where Abiword now does. Hopefully both will continue to have a large and growing shared feature base.

As some folks will know, ODF allows one or more RDF/XML files to be shipped in the ODF file, and for that RDF to be linking to the document content from the content.xml file. This means that you can explicitly say that a 1/2 inch bolt is from a particular maker and was procured on the 3rd of January 2012 by going to their office at geolocation ?x. Handy when you are reading the document a year down the line and want to know which office you bought the bolt from and the exact length of its thread.

Looking at the below image, one can see the purple underlined pieces of text. Each of these has some RDF associated with it. The citation to Dan Brickley has both contact and location RDF associated with it. Looking at the toolbar, towards the right side you see an "R" to start a change tracked document, and the "RF" button. Sorry about the images there, I draw at the 3 year old level so my icons are not quite polished shall we say. Anyway, the "RF" button selects this reference to an RDF item. So if you are between the "am" in the purple "James" then the whole word will be selected with this button. The ">" and "<" buttons then allow you to move to the next and previous reference to the selected RDF item. As you notice another purple James later in the document, this is the second and only other reference to him and you can move between them using these buttons.

These purple links I call "RDF links", which is a bit of a play on hyperlinks or bookmarks. Behind the scenes they are implemented using xml:id values and pkg:idrefs to those from RDF.

A feature added in the last days is the ability to capture and navigate by the relation between two RDF links. This is currently done by selecting a "source" link and then clicking another rdf link and setting the relation to the source. So in the below screenshot I am saying that Mark foaf:knows James. You will also notice the "Find by Relation" option which I can then use to see the people that mark foaf:knows. In the spirit of the foaf definition, I have made this a symmetric relation. So there is no stalking, or "following", if James knows Mark then Mark knows James. Asymmetric relationships are also possible, like son, child, or contains. I am hoping to add this feature to Calligra too in the future as the relations between RDF objects is one of the more powerful features that can be offered by using RDF in a document.

Note that the prev/next RDF item buttons work with relations. If I pick mark and navigate to the James he knows then I can "next" from that james to select the second reference to James. This is one recurring theme to RDF in ODF, that RDF objects like contacts can be cited or linked zero or more times in the text content of the document.

As mentioned above, the converse is also true, and the Dan Brickley text has two logical RDF objects linked to it; Dan's contact information and his location. Handling this multi-object for a single site is a little tricky and in this editing will create a window with both the semantic objects in it to let you edit the RDF abiword knows about. Note that this dialog is actually backed by two (or more) SPARQL queries;

If you are not squeamish about your triples then the "Show RDF" option for an RDF link will let you get right at them and edit away as shown below. There are a few technically cool things about this dialog: firstly the "Restrict to RDF Link" combo box lets you select one or more RDF links that the triples will have to be associated with, and secondly abiword makes sure any edits you make are properly linked to the RDF link you right clicked on. What I mean by this last bit is if you right click the RDF link "alice33" add a new triple "uri:alive myvocab:likes uri:bob" then abiword will add the triple "uri:alice pkg:idref alice33" for you. This is sort of having abiword do what you mean in that you want the new triple to be associated with the link but don't necessarily want to have to explicitly say it all the time. By choosing to edit the RDF for the link you have already explicitly said once that you want these things to be linked. This also applies if you change a subject, uri:alice to uri:amanda will update the pkg:idref values for you. Keep it linked, keep it valid.

Going one level deeper, the above dialog is actually a subclass of a restricted RDF model created using SPARQL. The SPARQL model is read only, and the subclass, RDFModel_XMLIDLimited handles mutations by creating a wrapper object which takes care of the automatic triple relinking mentioned above. Those still awake might like to see the abiword trunk code for src/text/ptbl/xp/pd_DocumentRDF.cpp.

This is part of an ongoing mad hacking sprint that is leading up to a talk at LCA 2012 which starts in a week. Many of the things I mention here are not in trunk yet, and only tested on Linux/GTK+3. Those in Ballarat in a week might like to pop in to the talk given my Martin and myself on Friday the 20th.

das wiki == de filesystem

2011-11-22T15:07:00.000-08:00

The libferris virtual filesystem gains another tentacle, this time being able to mount mediawiki sites. Some cool use cases right off the cuff:

To read a wiki page
$ fcat wiki://$server/mediawiki/index.php/SamplePage
To write to a wiki page:
$ date | ferris-redirect -T wiki://$server/mediawiki/index.php/Sampler22

For those who are unfamiliar, ferris-redirect takes its stdin and writes it to the file you name. The -T truncates the file first. So the above is sort of like " >| " from bash but you get to write from any application to any libferris filesystem without using FUSE.

To plomp an image up on mediawiki:
ferriscp -av /tmp/Apple.png wiki://$server/mediawiki/index.php/

Which is then available as:
http://$server/mediawiki/index.php/File:Apple.png

And perhaps the coolest little trick so far, which doesn't rely on FUSE or mounting and uses an unmodified vi binary:

$ fedit wiki://alkid/mediawiki/index.php/Sampler22
... modify the "file" ...
ZZ to write it back to the web.

Also, I have tramp hacks to allow this to work from emacs.

Of course, this all interacts with other things libferris can mount, so you can "cp" from your scanner or webcam right to a wiki page or grab text from a wiki and create a pdf or print it out directly.

Oh, and there are Fedora 16 packages now too on openSUSE build service. Just run the following to get it all onto your system.

# yum install libferris-suite

Semantic Revolutions

2011-10-12T21:19:00.000-07:00

I thought a fun little scenario for RDF in ODF would be to bounce information from Evolution, through abiword, to calligra, and then drag it back into evolution again. So information goes from ical to RDF, crosses the clipboard as RDF inside of an ODF file with linked text, and then is dragged back into ical format again. I notice a little timezone bug in there, but on the whole things work as one would expect.

Copy and Paste with Semantics...

2011-09-20T16:40:00.000-07:00

Copy and Paste now preserves RDF between both Calligra and abiword in both directions. This lets you select some text in a document in either application, copy it, and paste it into the other application and have the RDF that is associated with that part of the document go along with the text you selected.

In the below screencast, the document that Calligra is editing has some contact and event information stored in RDF. The three people in the first sentence all have contact information associated. As you can see, the RDF sidepanel in Calligra lets you know about this as the cursor moves around. James has his phone number captured in RDF which the edit dialog shows. If I select one or more of these contacts and "Copy" them to the clipboard, Calligra creates an ODF file with embedded RDF in it and offers that on the clipboard.

Abiword is happy to accept that ODF content and when you paste it into a document you can see that the RDF links are preserved, and that there are 7 RDF triples associated with James. Of course, you want full disclosure of this information, so clicking show RDF lets you examine and edit those RDF triples.

Copy and Paste of RDF from Calligra to Abiword from Ben Martin on Vimeo.

I put a little trick in going the other way just to spice things up a little bit. The multi.odt file that I have open in abiword has two RDF links in scope at the Wing-B link. RDF is associated with the whole paragraph and explicitly with the link itself. In particular, the uri:widetime is associated with the paragraph while the uri:wingb is associated with the RDF link itself. Once I grab that RDF link and copy it to the clipboard, again an ODF file is offered (as well as text and rtf), and again Calligra is more than happy to accept an ODF file on the clipboard. Notice that when I show all the RDF in Calligra both the widetime and wingb RDF triples have now become part of the document.

Copy and Paste from Abiword to Calligra from Ben Martin on Vimeo.

I made some changes in both calligra and abiword to get this to happen. Changes to the former were quite small. You'll have to grab trunk from both applications if you want to play along at home. The code is committed in both trees.

Bringing back /dev/pcm

2011-09-13T16:23:00.000-07:00

Taking a peek in /dev/snd one might find device files for their sound card(s). Sequencers, Timers, midi, and pcm device files. I thought it might be interesting to apply a modern face lift to these devices; so now libferrris can mount pulseaudio and has write support for gstreamer.

What this means is you can write "audio" data to a virtual filesystem and have it play that back for you:

$ cat /tmp/sample.flac | ferris-redirect -T gstreamer://output/audio

ferris-redirect is like the shell pipe character but allows direct access to libferris filesystems without mount commands. The -T truncates, so it is like a ">|" bash redirection.

I also plan to make these output directories special. If you write to them like they are a file as in the above then it puts your data there. If you create a subfile and write to it you will be essentially writing to the output file itself. With that you could "cp" a directory of audio files to gstreamer://output/audio and they will play one at a time until you have copied them all to your speakers ;)

$ ferriscp -av /tmp/bongos-dir gstreamer://output/audio

Pulseaudio is available at pulseaudio:// or the shortcut pa://. The tree currently allows you to mute and alter the volume for playing streams and whole output devices. Reading a volume file will tell you the percentage that channel outputs at (or the average for volume-all). Writing a float to the volume files changes the volume to suit your request. The mute files similarly show if the audio is muted and allow you to set that by writing 1 or 0 to the file.

$ fls -0 pa://output/default
mute 0
volume-0 0.729996
volume-1 0.729996
volume-2 0.729996
volume-3 0.729996
volume-4 0.729996
volume-5 0.729996
volume-all 0.729996

$ echo 0.7 | ferris-redirect -T \
"pulseaudio://streams/amarok/Audio Stream/volume-all"

All this ferris-redirect stuff can have it's additional typing mitigated using a suitable inputrc.

For example:
$ cat ~/.inputrc
$include /etc/inputrc
">>>": "| ferris-redirect "
">>|": "| ferris-redirect -T "

This will be in the next libferris release tarball. Things slowly get closer for the libferris QML mobile audio app. You can already do index and search with libferris and get at the results as a QModel for use in QML, now you can also set volumes and "copy" sound to the earphones.

Abiword RDF Drag and Drop

2011-09-01T21:26:00.000-07:00

Now that abiword has low level RDF support I thought I'd make it simpler to get some data into the document's RDF. The initial support lets you drag contact and calendar entries from Evolution into your document as shown below. Notice that a new RDF Link is created for you and when you choose to right click that link and "Show RDF" there are many RDF triples that have been created by the D&D action.

Abiword RDF Drag and Drop from Ben Martin on Vimeo.

I think these sort of user interface additions help to make using RDF quick and easy, even for those who don't know or care what it is and where it gets stored in the document. Abiword can load and save RDF in both it's native abw files and ODF formats. You can of course convert between both without loosing the RDF ;)

I plan to add D&D in the other direction later on, so you can pickup a person from a document or an event. Similar to how many email clients let you import ics calendar files into your local Calendar. Having RDF in ODF lets you share content, style, and semantics, all in a truly open format single file.

Oh, and the code should hit svn trunk real soon now.

RDF Low Level Interaction in Abiword

2011-08-18T00:34:00.000-07:00

I've recently mentioned creating and jumping to the RDF Links (xml:id to RDF bridging) in Abiword. I also had a work in progress dialog to allow SPARQL Query execution. Things are moving along quite nicely and the RDF subsystem continues to get stronger with a Triple Editor and updates to the SPARQL dialog shown below and execution support.

Shown below is the new RDF Editor dialog. The file menu allows you to import and export RDF/XML files into the document. The Triple menu has the same actions as the toolbar; new, copy, and delete. Shown at the bottom of the dialog is the total number of RDF triples for this document. Clicking on a cell in the table lets you edit it and you can use the existing URI prefixes if you like, for example rdf:type instead of the full URI. I have to allow configuration of those prefixes yet.

When you select some text in Abiword you can use Insert/RDF Link to create a new RDF link for that text. This is much like making a bookmark, hyperlink and other items.

The context menu for an RDF link allows you to edit the RDF associated with link. That window is shown below. There can be many RDF links in scope at any location in the document. Consider the case where a paragraph has RDF linked to it and a sentence and word does too. So when you bring up the RDF editor window from the context menu of an RDF link you get a combo box letting you select which links you want to see the RDF associated with.

By default the editor shows you all the RDF Links that are in scope where the cursor was located when you opened the dialog from the context menu. In this case widetime is an RDF link for the whole paragraph and wingb is for three words at the end of the paragraph. The dialog shows you the triples that link the subjects to this location: those with ?subject pkg:idref widetime. Selecting a different RDF link from the combo box restricts the triples shown to be only those associated with the RDF link you have chosen.

I decided to make the dialog automatically link any new triples you create or edit to the RDF link you have specified in the combo box. If there is more than one RDF link shown then the first link is used for new and updated triples.

This allows you to select some text, create an RDF link, right click the link and "Show RDF" from the context menu and start adding and editing triples and Abiword will automatically associate all those shown with the RDF link you have selected. Yay, full, low level RDF support with a GUI ;)

In case you have forgotten the scope of an RDF link in the document, the RDF editor will select the scope in the main document when you select a triple in the editor. I might make that functionality have a toggle button in the toolbar instead of making it happen automatically all the time.

One of the plugins that comes with Abiword is the "AbiCommand" which gives you a console interface to Abiword. You can start it from the shell using:

$ abiword --plugin AbiCommand
...
AbiWord command line plugin: Type "quit" to exit
AbiWord:>

I have added some new RDF commands to the AbiCommand plugin which allows fairly good interaction with RDF from the command line. The context-model commands allow you to set and interact with a submodel of all the RDF in the document. For example, only the RDF that is associated with a given xml:id. All updates to RDF happen via a mutation object. So you first use rdf-mutation-create, then add/remove as desired and complete things with rdf-mutation-commit. For those who are still reading now, see pd_DocumentRDF.h in the C++ source code and you'll notice createMutation() in the model, with add(), remove(), commit() and rollback() methods. The new commands in AbiCommand are shown below:

...RDF subsystem...      

Where a function reads RDF, it will try to use the RDF context model if it is set

Otherwise the entire RDF for the document is used.

An RDF context is obtained using rdf-set-context*

and cleared with rdf-clear-context-model

                     

rdf-import <src>               - load all RDF from an RDF/XML file at <src> into the document

rdf-export <dst>               - save all document RDF to an RDF/XML file at <dst>

rdf-clear-context-model        - RDF can at times use a context model which is a subset of

                             all the RDF associated with the document.

                             This command clears that and uses all the RDF again.

rdf-set-context-model-pos <pos>       - Use a context model with the subset of RDF

                                    associated with the given document position

rdf-set-context-model-xmlid <xmlid> [readxmlid1,readxmlid2]

                                  - Use a context model with the subset of RDF

                                    associated with the given document xml:id value

rdf-context-show-objects  <s> <p>     - Show the object  list for the given subject,predicate pair

rdf-context-show-subjects <p> <o>     - Show the subject list for the given predicate,object  pair

rdf-context-contains      <s> <p> <o> - True if the triple is there.

rdf-context-show-arcs-out <s>         - Show the predicate objects associated

                                    with the given subject

rdf-get-xmlids                 - Get a comma separated list of the xml:ids assocaited

                             with the current cursor location

rdf-get-all-xmlids             - Get a comma separated list of all the xml:ids

rdf-get-xmlid-range <xmlid>    - Show the start and end document position associated

                             with the given <xmlid>

rdf-movept-xmlid-start <xmlid> - Move the cursor location to the start of the range

                             for the given xml:id value

rdf-movept-xmlid-end <xmlid>   - Move the cursor location to the end of the range

                             for the given xml:id value

rdf-uri-to-prefixed <uri>      - Convert full uri to prefix:rest

rdf-prefixed-to-uri <uri>      - Convert prefix:rest to full uri

rdf-size                       - Number of RDF triples for context

rdf-mutation-create            - Start a RDF mutation for the document

rdf-mutation-add    <s> <p> <o>- Add the given triple to the current mutation

rdf-mutation-remove <s> <p> <o>- Remove the given triple in the current mutation

rdf-mutation-commit            - Commit current RDF mutation to the document

rdf-mutation-rollback          - Throw away changes in current RDF mutation

rdf-execute-sparql             - Execute SPARQL query against RDF context

rdf-xmlid-insert <xmlid>       - Insert xml:id for current selection

rdf-xmlid-delete <xmlid>       - Delete the xml:id from the document

Some examples of AbiCommand interaction are shown below to give a little idea of use. These are using the multi.odt from my plugtest github repository.

load       /tmp/multi.odt

rdf-export /tmp/output.rdf

rdf-import /tmp/extra.rdf



rdf-set-context-model-pos 1006

rdf-export /tmp/1006.rdf



rdf-set-context-model-xmlid wingb

rdf-export /tmp/wingb.rdf



rdf-clear-context-model

rdf-export /tmp/all.rdf



rdf-get-xmlid-range wingb



rdf-execute-sparql "prefix rdf:  <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

prefix foaf: <http://xmlns.com/foaf/0.1/>

prefix pkg:  <http://docs.oasis-open.org/opendocument/meta/package/common#>

prefix geo84: <http://www.w3.org/2003/01/geo/wgs84_pos#>



select ?s ?p ?o ?rdflink

where {

?s ?p ?o .

?s pkg:idref ?rdflink .

filter(  str(?rdflink) = \"wingb\"  ||  str(?rdflink) = \"widetime\"  )

}"





load /tmp/multi.odt

movept +27

selectstart

movept +4

rdf-xmlid-insert foo

save /tmp/updated.odt



load /tmp/multi.odt

rdf-context-contains   uri:wingb rdf:type http://www.w3.org/2002/12/cal/icaltzd#Vevent

rdf-context-show-objects  uri:wingb rdf:type

rdf-context-show-subjects rdf:type  http://www.w3.org/2002/12/cal/icaltzd#Vevent

rdf-context-show-arcs-out uri:wingb

RDF Linking in Abiword

2011-08-02T22:27:00.000-07:00

Another minor step forward in the quest to make the RDF facility in ODF more useful to document authors... Abiword can now create links to RDF and you can jump to these links in a similar manner to how bookmarks work. The upside to using RDF links over bookmarks is that you can associate meaning with the RDF links. So for example, the text "Barry" can be associated with his vcard and possibly normal work geolocation.

Making a new RDF link is just like inserting a bookmark:
And the "Go To..." dialog now offers RDF links as first class citizens. I did a little tweaking to this goto window while I was at it; moving things into a paged configuration and abstracting out some common code into utility functions.

On the API front, there are now STL like iterators for the RDF and that theme will be present in the query results engine and perhaps also in the arcsOut() API. Speaking of querying, the window for SPARQL is coming along. I'll start working on the actual query execution shortly. Notice that the RDF triples are shown with namespaces in effect so you get something more readable.

As I mentioned in my previous post, the purple links can be turned on and off to highlight parts of the document with RDF associated. Using a special menu item you can pull up the SPARQL query dialog with a preformed query to show just the RDF associated with the current cursor location.

I admit that some of this is quite low level, for example directly inspecting the triples for the cursor position. But full disclosure isn't a bad thing right? I syndicated this to planet KDE because Calligra handles RDF too. Hopefully posts about RDF are interesting to hackers regardless of the desktop platform :)

Abiword & RDF Gusto

2011-07-19T22:04:00.000-07:00

I recently blogged about updating Calligra to improve its RDF support and bring back support for viewing and editing location information using Marble. A computer loves RDF because it is nice and verbose and allows low level unambiguous expression of semantics in a format that a machine can work with. For a human however, some might find having long descriptors, schemas and the like just to say "meet me at the Mall" a little tedious. One of the many challenges that I see for office applications wanting to offer RDF to the user is making it visible in a subtle way.

Abiword can now colour code parts of the document which have RDF associated with them and tell you how that association is formed, and how much RDF is linked at any point. In the below, the purple text has some RDF associated, and the purple "Mark" I have the mouse pointer on so it shows the bubble text letting you know how the RDF is attached and how much of it there is.

In the future I of course want to let you know more; is the RDF location, contact, event, or related to another domain. It would also be nice to highlight RDF only for types. So, for example if you are interested only in the times that trains leave then highlight departure logistics in bold red. The computer knows what you mean too, so might also want to offer a menu button to check if the train is on time or not.

Being able to highlight like this is a good start because it allows users who are unfamiliar with the document the chance to know exactly where there might be RDF "hiding".

Calligra & RDF Smaak

2011-07-15T16:16:00.000-07:00

As some readers will already know, the ODF document standard has support for including one or more RDF/XML files. I have made a few such files, and will grow that collection over time. The weekend hike document cites a few people, links some to a location and also cites a time and place. While one could just say "Dom Plein" or "11 am Wednesday" these purely text references are subjective and require a human to read them.

On the other hand, the location could have an exact bounding polygon or point with digital longitude and latitude information. A computer is all to happy to use that precise description to offer maps and "how to get there from here" type information. And the 11am is of course dubious because it doesn't link to a timezone, a human will know we are not talking UK time or the ACDT timezone. But that requires inference from the cited location and knowledge of which Plein that is, or rather, which timezone that Plein is in.

I did a little hacking to freshen up some of the RDF code in Calligra and bring back optional support for using Marble to show and edit location information. The below is the weekend hike example from the github above. James, Joyce, and Mark all have contact RDF associated, with Mark also giving his location. The "next weekend" at the end of the first paragraph has both a time and place associated. In the screenshot I've opened up the place to edit it. Rather simple to drag a map around and click OK than to know the digital coordinates right of the top of your head ;)

I was hacking on fixing the same bug as boemann on #calligra, which is strange for me as I normally don't overlap on things. It seems along the way setCanvas() was called again so I removed my explicit view passing stuff in the update I just git pushed. It looks like the docker was fixed correctly by somebody else in the end. My SPARQL updates should still help. It has been a while since I hacked on this codebase, and I have to thank the Calligra guys for being so welcoming and having such a fun contribution environment! I'm fortunate to be able to hack on two projects, Abiword and Calligra, which are both so welcoming :)

RDF in ODF: Abiword & Calligra

2011-07-11T17:48:00.000-07:00

RDF has been slowly making it's way into Office applications. The ODF standard includes support for shipping RDF/XML file(s) inside the zip file that is an odt file. This RDF can also be linked to particular part(s) of the document text so that you and your computer both know where the RDF is most relevant. For example, if "Fred" in the document has his phone number, location, and cake preference in RDF, that can all be linked just to the four characters "Fred" so that it all makes sense. Strange as it might be, not everybody likes Baumkuchen, and it is fairly likely not to be relevant to a stock quote in another part of the document.

RDF has spread to OpenOffice, abiword, KOffice, and Calligra. All of these applications can read and write RDF in text documents. The later two also include a GUI to allow you to query, inspect, and update the RDF. Since I'm hacking on abiword, I've been throwing around how to best expose RDF to the person using abiword for document editing...

First, this is what Calligra does. The main document window includes an RDF docker which shows you the high level "Semantic objects". These are things which make use of many RDF triples to present a single object type such as a contact, calendar event, location, or explicit train trip. Note that the RDF docker only shows you the semantic objects for the RDF which is relevant to the current document cursor position.

The Document Information window also lets you get at all of the RDF which ships with an ODF file. The Semantic tab is very similar to the RDF docker but shows all the Semantic Objects regardless of where they are relevant in the document (if at all). As you can see below, editing the "Dan" person semantic object you can set their name, nickname, phone number, and homepage. Of course, more information is relevant to people and this whole section should be expanded to cater for that. And yes, for Calligra having a good hookup to Akonadi would be of great use for all.

Contacts use the FOAF RDF schema in Calligra. This allows not only contact information but also the relations between contacts to be expressed. FOAF is about Friends of a Friend after all. Looking at the above you might think name, phone etc are each going to be a triple in the RDF from the document. The triples tab lets you get at that lower level RDF goodness as shown below. A few things to note; while RDF is triples, each object has a type (is it a chunk of text or a link to another subject), and since there are many possible "files" the RDF/XML came from that is tracked for each triple so they can go back there too on save.

Notice in the above that prefixes are included in the subject, predicate, and object columns. This is an attempt to make the raw RDF less verbose and somewhat simpler to handle. The namespaces tab lets you set these up. Any namespaces that are used in the RDF/XML from the ODF file are automatically added and used for you.

The stylesheets tab I'll cover at another time. The SPARQL tab lets you run a query against all the RDF for the document. The one I've run here is the default one that Calligra shows you, which will select all the triples from the document without restriction. The subject, predicate, and object resulting are shown in the bottom half of the window.

I was thinking about all of this recently because I'm now looking to add GUI stuff to abiword to allow RDF interaction. The first idea was to simply add a "edit RDF" context menu item to allow you to associate one or more triples with the cursor position or current selection. The ability to define and reuse namespaces would also help to make such a dialog less painful to use. This brings the design close to the combined "Triples" and "Namespaces" tabs of the Calligra Document Information window. This might be OK for determined users who already really, really know they want to do these things. But I tend to think there are more folks who could take advantage of using RDF but not necessarily care about it.

Simplicity for users was the driving force behind the design of Semantic Objects and the use of Drag and Drop to and from other applications to create and harvest RDF data. I think it is much simpler to grab the "Fred" contact from Evolution and drop it into the document than to work out that you want to use FOAF and the exact predicates to create a well defined RDF graph for the Fred contact and then copy and paste each of those pieces of data individually.

One might like to consider the Triples+Namespaces as a special type of Semantic Object, a "raw" object if you will. This brings together the design of the advanced and user friendly interaction into a single dialog. As the namespaces are likely to have whole document scope they can be setup and edited elsewhere. Unfortunately I had a bit of trouble working out how to populate a tree or list in glade-2 or glade-3 for mock ups, so these are gimped a bit too.

The dialog below is a semantic object editor with the advanced tab allowing raw interaction. As there can be zero or more semantic objects of a given type in scope at any point there is a list on the left side allowing you to choose which object of a type to view. Perhaps that should be a drop down list at the top of the tab to save screen space.

The email and VoIP links should start a new message or request a phone call with the person respectively. Such actions should also be available without getting to the editor itself. My current plan is to have the advanced tab allow interaction with the raw triples. Remember though that triples carry type information, possibly extra context, and/or perhaps a range of the revisions in a change tracked document that the triple is valid for. So its by no means just a list with three columns as the name triples might at first imply.

A somewhat problematic first blush at this gives the below. I'm thinking that the subj, pred, and object strings can be namespace:foo strings, possibly with some completion for known namespaces like foaf, et al. The type is fairly OK as these are fixed and mainly URI or Object.

The revision range selection is a real challenge. This might become some sort of date range bar line the timeline or timeplot from the simile widgets. The trick as is usual is extrapolating the extra dimension from what is in it's vanilla sense a linear one dimensional data set ( time, revision ). Though having the revisions and their descriptions in the top half of the timeline and the ability to pan and zoom seeing a density plot in the lower half would work for starters.

I'm thinking that as well as showing you all the triples that maybe allowing simple one or two line SPARQL to be run to find the triples to edit would be preferable. Perhaps it doesn't add much for a small document range with only 20 triples associated, but to use the dialog on the whole document too, you might want to limit triples to "current revision" and foaf related only for example. Using a triple list allows you to sort by column and search, but such a search could also be performed with relatively simple SPARQL. And normally, and extremely unfortunately, one normally doesn't get to stable sort lists by 2+ columns. A limitation I try to avoid inflicting.

So in summary, raw triple editing can be just an advanced semantic object. The list of semantic objects should be able to be found from a document position (cursor) or arbitrary begin-end range. The later catering for whole document RDF editing as a special case. For contacts there might be one or more semantic objects for any doc position or range, but there will only be one raw-triple semantic object for any range.

Though I'm still chucking around how to make the query/edit part most convenient for users for the raw triples semantic object.

Libferris for Fedora 15

2011-06-18T18:46:00.000-07:00

My openSUSE Build Service project now has rpm files for Fedora 15 for the libferris chain including gevas and the ego file manager. This includes the recently mentioned updates to postgresql indexing allowing for indexed resolution of some regex queries (2ms query time on 200+k files).

During the updates, I found the normal little things such as gcc being more selective about what it likes to compile and treated these cases. The main glitch I found was in the @F15/../gtk/gtkmain.h header there is a prototype which takes a "GModule *module" argument. This means I had to include gmodule.h before gtk.h to get that type in scope otherwise things failed to compile.

The Fedora 15 packages have support for printing with Qt, so one can echo foo > printer://default/ or "cp" an image to the printer. Scanning support will pop up in a future build once the few tiny changes to ksane I sent in trickle through to the shipped KDE release in Fedora.

Perhaps soon I'll make Phonon available as a filesystem too so one can cp an ogg file to sound://default to play it. Seeking will be interesting, as it's not normally a common case to start copying a file at a given offset. But that smells like a seek during playback to me. I'm looking forward to making a QML audio player, with index-search and playback already filesystems the heavy lifting will have already been done :)

Searching again (400ms -> 2ms)

2011-05-02T03:12:00.000-07:00

The problem statement: you want to search for a file using any arbitrary substring contained in the file url. This is deceptively hard, if you think in a relational db way, you want something "like %foo%" where the leading percent will force indexes to be considered redundant and a sequential scan to ensue. If you try instead to break up the file's URL into words and use a full text indexing solution you will find your old friend the leading percent again, like here for Lucene.

One easy way to use full text indexing style and allow substrings is to cheat. First disable word stemming (ie, dont turn diving and dive into a stemmed "dive" word). Then for each word to be added to the full text index, shift it left from 1..10 times. So wonderful, onderful, nderful, derful, erful etc are all added as words for the same URL. This is most simply accomplished using a postgresql function to do the shifting.

Then when you search for a substring foo you want to find to_tsquery('simple,'foo:*') as a fulltext query on your url column. As prefix searches are allowed in fulltext index engines like Lucene and postgresql's TSearch2 engine, this evaluates quite quickly.

For 200,000 URLs when using the raw regex match "~" in postgresql you might see 400ms evaluation times, the same data using a gin index on to_tsvector('simple',fnshiftstring(url)) might return in 2-3ms. Of course the index can't always handle your regular expression, but if you can tease out substrings which must be present from your regular expression, a shifted gin index could drop evaluation times for you. eg, .*[Ff]oob([0-9]... could use a shifted search for "oob" as a prefilter to full regular expression evaluation.

Getting down to a few ms evaluation allows GUIs to return some sample results as you type in your regular expression. This speed up will be available in 1.5.6+ of libferris.

A while ago I released an engine for maemo with statistical spatial indexing for regular expression evaluation. It's an interesting problem IMHO, and its also a very common one.

Everything is a file? Spitting it out again...

2011-04-29T22:16:00.000-07:00

After recently adding support for scanning through a virtual filesystem interface in libferris I thought I'd complete the cycle and add printer-as-filesystem too. This of course allows the neat trick to "copy" a document from your scanner and dumping it to a printer:

$ ferriscp scanner:///my-scanner/color/scan.png printer:///my-friends-printer/

Naturally the printer and scanner don't have to be in the same room etc. As you can see from the above, writing a picture to a file inside the printer's virtual directory prints that image to paper. By default images are smooth stretched to fit the entire page, not a huge issue if you scan and print at the same DPI.

Images can come from anywhere, to hard copy a webcam
$ ferriscp gstreamer://capture/webcam.jpg printer:///Ich-bin-ein-drucker/

If on the other hand you write a plain text file to the printer's directory it will be printed in an acceptable manner too. So something like this works

$ date | ferris-redirect -T printer://Cups-PDF/foo

In this case, you can expect a ~/Desktop/foo.pdf file which is a PDF document with the current date in it. One can think if ferris-redirect as the shell "|" but which natively knows about all the libferris filesystems. On the other hand, you could use FUSE to mount printer:// at some normal kernel location and just do
$ date >| ~/printer/Cups-PDF/foo

Of course, none of this is meant to replace programs which let you tweak how images are printed, format how text will appear, or select from the myriad of options your printer offers you. But if you want a piece of paper from a scanner to a printer, such a "copy" might be just the ticket.

Blocking a nostril

2011-04-26T20:35:00.000-07:00

I have been meaning to add sane support to libferris since I upgraded my scanner to something modern. I now also have an Automatic Document Feeder (ADF) so naturally that needs to be a filesystem too. A quick example of how this might be useful, to turn a document into something on screen quickly:

$ fcat sane:///my-scanner/color/scan.jpg | okular -

The trees under sane:// allow preconfigured scanning units and discovery. If you have setup my-scanner then no device listing is performed with sane, a good thing because discovery can be slow. When you configure a scanner you create one or more directories with specific configurations of how you want the scan to proceed. Incidentally, configuration is of course done with a filesystem. Inside ~/.ferris/sane you create a directory for your scanner, plomp the device name into scanner/device and create directories with scanning options for that scanner.

As well as scan.jpg there is a directory "adf" which chomps new things from the ADF for each file you read. Having this directory allows you to grab 20 documents by a normal looking posix like command such as:

$ ferriscp -av sane:///adf/gray-100/adf /tmp/

in this case, I made two trees, color-N and gray-N which scan in color or grayscale at a given DPI (100,300,600 etc). So I can get most of what I want by picking the right directory. "adf" is a softlink to my scanner (a local link in ~/.ferris/sane from adf to "my-scanner"). Using links like this means I can replace the hardware and scripts can still just ask for "the adf" scanner and get something.

One might wonder what happens for a scanner which is not known to the system. The ".discovery" configuration inside ~/.ferris/sane provides defaults for such devices, so you can have your color/gray DPI directories magically appear for discovered scanners too. Of course, most of the gray directories are similar, so softlinks are your friend except for the "resolution" file which you want to change per directory.

Discovery isn't performed for the above commands, because libferris uses short cut directory loading as it knows explicitly how to make the virtual filesystems for preconfigured scanners.

Some hints on configuration will be in dot-ferris/sane/dot-discovered which will be in libferris 1.5.6+ along with the code to actually make it happen.

Change Tracking: Why?

2011-04-24T17:40:00.000-07:00

As some of my past posts have mentioned, the OASIS group is currently working out how it wishes to extend support for change tracking in ODF. The change tracking feature allows you to have an office application remember what changes you have made and associate them with one or more revisions. There are many examples where governments might want such traceability, but small businesses are likely to find this functionality valuable too.

Late last year there was an ODF plugfest held in Brussels where it was decided that an Advanced Document Collaboration subcommittee should be formed to work out how to serialize tracked changes into ODF.

There are currently two proposals. One which is generic and tracks how the XML of the ODF is modified over time, and an extension to the limited change tracking that already exists in ODF 1.2.

As my previous posts have mentioned, I'm involved in making abiword able to produce and consume ODF files which contain tracked changes in the format of the generic proposal.
See my github for abiword and its change tracking test suite. Ganesh Paramasivam has been working to make Calligra and KOffice support the generic proposal too, and Jos van den Oever has done some hacking to enrich WebODF for change tracking.

As I have been going along implementing things in abiword, I've been clarifying some points on the oasis office-collab mailing list, and participating in some of the general conversation there too.

Some of the differences between the two proposals can have a large impact to the complexity of implementing change tracking in applications. Folks who are involved in office applications which use ODF might like to read up on the proposals and have their say on the future of this feature before a decision is made for you.

I think it is important for ODT to include a good, complete change tracking specification because it would offer all people the ability to collaborate on documents and businesses the change to know the exact extent of modifications made to documents by each party.

ODF and Generic Change Tracking: part II, styles.

2011-04-16T21:12:00.000-07:00

So now abiword can save and load ODF files with improved generic tracked changes to styles. These style changes might be nested, and the window that a style is applied to might shift over revisions. The below video demonstrates the scenario in example 6.4.2 of the generic track changes proposal that is being considered by the Advanced Document Collaboration OASIS ODF Technical subcommittee.

The actual serialization to ODF is along the lines of my proposed output but also using the ac:change stack to avoid unnecessary nesting as has been mentioned that OpenOffice might produce and consume if the generic proposal were to be chosen by the oasis subcommittee.

ODT Change Tracking part 2: Example 6.4.2 from Ben Martin on Vimeo.

Libferris for Fedora 14

2011-04-13T06:51:00.000-07:00

Long story short, I decided to update to F14 on the desktop to get easy access to qt4.7 for a project. During that update I rebuilt libferris (of course) and noticed a not so subtle bug in boost 1.44 that comes with f14. See my filed bug 694448 for full details, but basically it stops boost::serialization from reading binary boost archives from files generated with f13's boost. To get around this, the build of ferris includes some more smarts in fallback to the backup text archive.

Lucky for me, in the old days I wanted to copy some *boost files to the maemo platform, and not being 64bit on the target binary archives are not expected to work, so I already had libferris writing plain text too when updates were made. So on f14 things continue to work, and 1.5.4 of libferris onward have more graceful automatic fallbacks for cases where the binary archive fails when it really shouldn't.

You might see this bug if you use semantic smush sets, etagere (tagging), and a few other libferris features with ferris 1.5.3 or less and move to a boost in the 1.42-1.44 range.

Given that F15 should be out soonish, and it seems it will come with boost 1.46, I'm not sure backporting boost::serialization fixes is really on anyone's top ten.

ODF and Generic Change Tracking

2011-04-08T22:14:00.000-07:00

The OASIS group who are responsible for things like the Open Document Format (ODF) format are throwing around how to improve how change tracking information is to be contained in future versions of ODF. I've hacked some support for the "generic" change tracking proposal into Abiword in a git branch, and Ganesh Paramasivam has been working to make Calligra and KOffice support this too.

I thought a little bit of a look at how documents move between suites was in order. Obviously, these are really trivial changes. The larger use cases screem out for an automated system to test them, so that regressions can be caught and other office suites added over time if they choose to support this method of change tracking.

So, without further (or less) ado, the below video shows a document created in KOffice and bounced through a temporary file to abiword and inspected. Apologies for the delays in the first video, I've sorted that issue of frame dups out for future shows.

2011 April 9: KOffice and Abiword with Generic Change Tracking 1of2 from Ben Martin on Vimeo.

In the second video I make some changes in abiword and send those back to KOffice. In the process I found a few little issues which I've committed some updates to the abiword git repo to help with.

2011 April 9: KOffice and Abiword with Generic Change Tracking 2of2 from Ben Martin on Vimeo.

These videos where created with recordmydesktop, transcoded with mencode for 720 playback (mainly getting the video codec how vimeo wants to see it), and uploaded with ferriscp foo.avi vimeo://upload.

Abiword with ODT and Generic Track Changes

2011-04-01T04:23:00.000-07:00

I've been hacking support for the proposed generic track changes for ODF into abiword recently. This means that you can generate and store documents with many revisions and see who added/deleted and modified what in which revision over time. Kind of handy for sending your professor the latest design for your perpetual motion machine and being able to see where they think your design might be too optimistic ;)

Anyway, both the branch of abiword and a test suite are up on github to allow anyone to grab it, prod it in the guts, and see how things might operate. Be aware that this is a work in progress right now, and I might commit stuff which is still a work in progress.

The code is at
https://github.com/monkeyiq/odf-2011-track-changes-git-svn
The test suite is at
https://github.com/monkeyiq/odf-2011-track-changes-tests

The following instructions will build abiword from the change tracking code on github. The build will install into /tmp and will not interfere with an abiword which is installed from your Linux distribution's package system. Both abiword builds will be available to you.

$ mkdir tmp
$ cd ./tmp
$ git clone https://github.com/monkeyiq/odf-2011-track-changes-git-svn
$ cd ./odf-2011-track-changes-git-svn
$ ./autogen.sh
$ ./configure --enable-debug \
--enable-collab-backend-service \
--enable-clipart \
--enable-templates \
--prefix=/tmp/abiword-install-odfct \
--enable-plugins="collab"
$ time nice make -j5
$ make install
$ /tmp/abiword-install-odfct/bin/abiword

The download can be done in reasonable time over ADSL, on an Intel Q6600 the make took about 4 minutes. You might like to adjust the -j on the make line to suit your core count. Notice that since everything is installed into /tmp you don't have to run the install as root either. You will get debugging output in the console when using abiword built this way, but that's what you want when running dev code right?

Starting to use change tracking is really easy now too. Though I need to convince somebody who can create clipart to make new icons for revision handling, so the arrow in the below points to the main toolbar icon you want to know about. The icon directly to the right of it will let you select a revision to see from a list.

At first, the additional icons to the right of will not be visible to you as they are only useful when you are using track changes. Each time you click the icon with the arrow pointed at it, abiword will ask to to name a new revision. This makes it nice and simple to create a 5-10 revision test document to play with ODT and Change tracking. Note that abiword can save the change tracking information in it's native abw format as well as ODT. In fact, that is what the core of the test suite linked above does; convert between these formats and make sure that nothing is lost in translations. This way you get to know that abiword can write *and* read back its ODT files without loosing precious information.

"The desktop" and singularity (also scanning and ferris)

2011-03-21T21:43:00.000-07:00

While I normally don't waffle on about higher level touchy feely sorts of things, a recent acquisition of a new scanner prompted my mind to wander through those neurological paths. I think it's fair to say that many folks don't run just one, but many desktops these days. And no, this is not about KDE vs GNOME vs emacs as your desktop, but rather that a whole KDE4 session is happening on another (virtual) machine which is brought across to the normal "main" desktop.

This gives me many apps running on many machines and also proxy X sessions and X-VNC sessions in windows (which normally have an embedded panel et al). A take away idea I had here was why when I have Abiword in the menus is there not an offer to run it on server-Y which I have an ssh key for instead of the local host? Or to bring xpra into the mix there as well. Sure, this is likely not an idea that folks who only own a single machine or laptop will like, but that demographic is surely shrinking fast. Add in nepomuk for tracking this and if I run amarok on furryshark7 most of the time then surely that can become the default host for it's icon rather than localhost.

The scanner idea was simple, a USB scanner, a USB hub to attach it to the host through and a handful of USB sticks. Each stick has a profile (username, colour, dpi etc) and to scan just put the document into the scanner and drop in the usb stick for a moment. Then the host knows the parameters and can put the file into a user specific directory on an intranet share so only the document holder can actually see the scanned version. Privacy and convenience, a rare thing!

Of course now that I have a scanner which doesn't suck, libferris will be getting sane support so I can "cp" documents right from the scanner to the filesystem or web...

cp sane://my-scanner-model/600dpi/colour/adf1.jpg flickr://me/upload

And the reason files are numbered is so a single copy can grab 30 documents from the ADF with a normal copy syntax. In practice, adf2 and adf1 both just scan the next piece of physical paper and give you it encoded in an appropriate manner (jpg for example). The fun part will be smoothing over a paper jam at document 7 of 16.

sync && umount blog://

From Canon CR2 Raw files to the Web

2011-01-20T21:28:00.000-08:00

A potentially interesting artefact of me playing around with a Canon DSLR is that libferris now has some initial support for CR2 "raw" files. Complements of course go to the dcraw library and tools for the heavy lifting. The upshot is that ferriscp ~/cam/foo.CR2 flickr://me/upload now works as expected. Once I update my maemo build, this should also let me use an n900 with 3G to upload from RAW while on the move.

I need to include stuff for ICC profiles and the like but at least the Web services get what they expect and everything runs smoothly, and it will for you too next release (TM). I really should look into mounting the kipi plugins as a filesystem sometime, they offer some awesome Web import/export functionality, ripe for a filesystem I tell's ya.

I still need to add "rgba-32bpp" metadata support for CR2 files. As you can imagine from the name, if you read this metadata for a jpeg, png or other supported image file, libferris decodes the image to 32 bit RGBA byte values for you. It might also be interesting to create another "file as filesystem" design where a bunch of virtual files are offered to see the small thumbnail, the roughly 1080p sized thumbnail or the ICC corrected rendering of the CR2 and others. Such virtual files are really handy for drag and drop to other filesystems ;)

I might hunt around for some Nikon raw files to add support for those too at some point. Though there is nothing like having a camera generating files to make you want to make your software support those files.

Talking: RDF and Office Documents

2011-01-03T23:28:00.001-08:00

I should be giving a talk about RDF and ODF next saturday (8th jan) at Humbug in Brissie. The challenge is that work is reasonably embryonic in the area, but there are already useful things that can be done like drag and drop of contact and calendar information to/from ODF files. As its a technical meetup I'll be going into the range stuff and how to link semantics to document text. Sorry for the brief post, but hopefully you see it and come along if you want to bounce richer information around in ODF files between OpenOffice, Calligra, and Abiword.

Libferris hits the presses again...

2010-12-20T05:29:00.000-08:00

The January 2011 issue of Linux Magazine has some information on Federated indexing with libferris. Nice timing for the upcoming talk on libferris at linux.conf.au next month!

Foray into Qt Models with libferris

2010-11-19T16:26:00.000-08:00

Version 1.5.2 of libferris, released yesterday, includes both a QAbstractTableModel and QSortFilterProxyModel targeted at exposing libferris to the world of all things Qt. In libferris a great amount of information is exposed as virtual Extended Attributes for a file. As you can see in the below shot, the md5 as well as "ls -lh" size is available directly as attributes. Before you wonder, the md5 is only calculated on demand and is then cached relative to the mtime of the file.

Each file has thousands of attributes on my machine, these include tagging, geospatial information, extracted metadata, and RDF. In my GTK+2 model/view pair I allow the user to "sort" on a column but really have the view sort on another one. For example, as you see below, sorting on size-human-readable either means Qt or some class you provide needs to know how to properly sort on size strings like 14.2k etc. Instead of this, the QSortFilterProxyModel converts some column names into others, so a size-human-readable sort becomes a sort on the "size" column. As the latter is simply a number Qt knows how to do the right thing (TM). Although both columns are shown in the example shot, there is no need to have the size column visible too.

The mtime is actually converted to a QDateTime by the model. It is stored internally as an epoch integer. Thus the mtime-display column was added in libferris which shows you a human readable version. This is handy for command line tools and others which do not want to know about presentation etc and just want something nice to show the user. Most of these attributes in libferris have schema information, which makes it possible to pass them on to Qt in a nice way. Tags should come through as checkboxes etc.

The next logical step is to get at this from QML. I'll wait until I update to Fedora 14 which has Qt 4.7 in it. With the model, and some way to play back audio I should be able to make an audio player in QML. Two things help here; searches can return their results as a virtual filesystem which can then be shown in the QAbstractTableModel, and filesystem "selections" can be built as filesystems which can also be then displayed in the same way. So I have search and playlist support already from that and ffmpeg or some low battery way to make ogg into air oscillation then completes the loop.

Sharing is Caring...

2010-11-15T15:46:00.000-08:00

My repository now contains a steaming ferris-sharing-plugin_0.2_armel.deb which will hook up libferris to the Nokia sharing system on the n900. This lets you click the funky Brussels atom building "sharing" icon from many places and copy images to flickr, 23hq, facebook.

There isn't much feedback at the moment, that is planned for "the future". You might also like to install the ImageMagick from my repo. Simply expand it to /opt and make a link /usr/lib/ImageMagick-6.6.0 -> /opt/ImageMagick-6.6.0/lib/ImageMagick-6.6.0. This gives you proper handling of exif orientation during scaling prior to upload with libferris.

I also have some tweaks to libferris itself which will be in the upcoming 1.5.1 release to help with annotations etc during upload. The next step is to get vimeo and youtube upload support happening too, since libferris can already upload to those.

Pop Quiz Hot Shot - ssh

2010-11-12T14:17:00.000-08:00

You have ssh'ed into a host via three others and just noticed a file(s) you would like on the laptop you started all this merriment from, what do you do? Of course you don't have a control connection or tunnelling already setup because its a "once off" multi hop connection.

A solution that is not quite as widely known as I'd thought is to use the sz and rz pair. Hurrah the zmodem programs are still just as useful today as they were in the years of yore. The snag is that your local terminal needs to have some knowledge of this, konsole works nicely and will pop up a dialog asking where to save files "sent" to it. So doing ssh server; date >/tmp/df; sz /tmp/df will result in a dialog appearing on your local display asking where to save the df file to. Note that this works over multiple intermediate ssh hops. Just perfect for when you have routed your way into a protected network via 4 hops and find out that /etc/foo.conf which is 8kb would be *really* nice to have on the laptop.

This is packaged as lrzsz for Fedora and I've made an lszrz tarball available in my n900 repository. Let the zmodem goodness rain down...

Clawmotia and QML: Moving the TV

2010-11-08T18:20:00.001-08:00

Some may know that Clawmotia is my MythTV remote control which started back in the n810 days. For a bit of fun while recovering from jet lag I decided to port Clawmotia over to using QML and take advantage of some of the n900's capabilities such as the accelerometer. Shown below is controlling the playback speed by moving the device. Apologies for the flicking video, it seems mythtv doesn't like the mov file in software playback much, but the Bunny is free to use so he made the audition.

Controlling MythTV with an n900 accelerometer from Ben Martin on Vimeo.

The normal functions from the older qedje remote are also available on the main page shown in the video below. I have now put the cursor keys into a submenu which is opened by both the joystick and menu buttons, the latter first getting mythtv to open the menu and then changing the remote configuration to show the cursor key submenu. This explains the vacant positions in the grid in the new design -- submenu shuffle has given me a few extra spots to play with. Also the settings can be set in the program itself now instead of the old edit the launcher file and set environment variables. I would like to make the volume adjustment use a popup slider and also route the hardware vol +/- keys to mythtv, but I'm still working out how to do the later.

Clawmotia QML: The Qt MythTV remote control from Ben Martin on Vimeo.

Interestingly, the big "oh no" moments came when I tried to do trivial things from QML such as reading a file (the accelerometer in /sys). I would have thought that QFile was available but it seems not. Perhaps it is from dedicated javascript files or I'm just doing it wrong^TM. I also notice that the simulator doesn't update that /sys file so you have to test that on the device :/

I also bumped into other things like hooking up signals bidirectionally which would need pass by reference or similar to make it useful in custom QML elements. I might also make some data bound classes to use with QSettings, it seems like an idea for a QString like class to update the QSettings automatically when you assign new data to it.

I also tinkered in Nokias SDK environment for this but reverted to emacs and js-mode because there are just too many things my hands are used to happening that don't in the SDK editor. Though for QML stuff I suspect I need to update my elisp to have better "add property" support so the get/set/signal/member declarations are all added from a "QString foo" input. I have part of that done but need to revisit it.

CRUD, metadata, indexing and Trees, please

2010-11-01T15:17:00.000-07:00

For those in Australia who want to hear about libferris and doing interesting things with data using a everything is a file paradigm then you might like to drop by OSDC later in November and LCA in Brisbane in late January 2011. Both of these events will include a session with me talking about not only strange but also hopefully interesting and useful things you can do with your data using libferris.

Examples include mounting flickr, facebook, youtube, gstreamer et al. Just "cp" your image to upload. With gstreamer just "cp" from the camera on the n900 to your web service of choice. And heavier data manipulation like interfacing with SQLite and XQuery to get at any data the filesystem exposes such as these web services, berkeley db, relational data, dbus, running applications, composite files etc. I might also throw in some ODF processing such as using document forms to edit postgresql databases through virtual documents. Though what is in the main talk and what is in the post amble at the pub is yet to be delineated.

Open or Edit a QML file?

2010-09-29T17:33:00.000-07:00

One limitation of doing things based purely on the MIME type of a file is that sometimes things that might be sniffed as C source code are really not. This also comes up with XML files. One solution which feels like adding a level of indirection is having the sniffer say this is XML and what the schema is, or this looks like C source but is really a QML interface. While this blog post presents a libferris oriented solution, I thought I'd syndicate because the core problem is broadly applicable.

Because I tend to want to have the computer do different things for the same mime type depending on where it is located or other metadata, libferris lets you tell it what to do based on any arbitrary predicate, instead of a mimetype == value test.

Like most things, this is setup and edited using... drum roll... a filesystem. The filtered bindings are evaluated before the normal mimetype value tests, and if a filtered binding is found it is used instead of any "generic" mimetype based action.

So, for the Qt SDK, I can have double click run the QML application and middle click open the source in emacs with a setup like the one below. Notice that I restrict the override to only /usr/local/qt URLs so I don't go handing QML files from arbitrary sources to qmlviewer. For those new to libferris the "| ferris-redirect" is like the shell ">" but can operate on any virtual filesystem object directly, without using FUSE etc.


fmkdir mime://filtered-bindings/qt-qml
fmkdir mime://filtered-bindings/qt-qml/actions
echo '(&(url=~file:/*usr/local/qt.*)(name-extension==qml))' \
  | ferris-redirect mime://filtered-bindings/qt-qml/ffilter

ftouch  mime://filtered-bindings/qt-qml/actions/open
echo -n misc/qmlviewer \
 | ferris-redirect -a ferris-appname mime://filtered-bindings/qt-qml/actions/open

ftouch  mime://filtered-bindings/qt-qml/actions/edit
echo -n emacs \
 | ferris-redirect -a ferris-appname mime://filtered-bindings/qt-qml/actions/edit

These actions are used in the ego file manager as well as from the command line with
$ ferris-file-action -v foourl.qml
to view. Of course, alias fv="ferris-file-action -v" is your friend.

n900: The claw arrives!

2010-09-25T17:44:00.001-07:00

Clawmotia is a MythTV remote control written using Qt and EFL technology. My repository contains a tarball ready to install clawmotia onto an n900. Desktop shortcut optional :)

Simply extract the tarball into /opt on the device. From there, you currently have to install the desktop file yourself to get it onto the menus. Finally, you'll need to edit start-clawmotia.sh to tell the application where your mythtv server is at and which client you want to control through that server. I plan to add dynamic client selection and a user configuration window in the app itself, but I seem to have more plans than the clock allows.

Camera to Web the eagle has landed!

2010-09-22T15:16:00.000-07:00

Pop quiz, hot shot; an n900 sits before you and something wonderful is happening in the distance. You've love to take advantage of the rear camera and share images of the wonderful event on any flickr API website or some sort of facial book site. What do you do? The camera has all sorts of custom APIs to access it, and the web sites all need some authentication and use REST.

Well, for those who know me, or of me, the answer is quite simple... just "cp" the data from your camera to the Web. And I've now got this working on the n900. I tried the front camera too, but unfortunately it comes out quite underexposed on in house shots.

To read the camera, libferris uses gstreamer. Because there are a whole bunch of ways you might like to read information, frame rates, transcodings etc, you use a file in your ~/.ferris directory to tell libferris how to create virtual files for your input hardware like so:


cat ~/.ferris/gstreamer.xml 
<gstreamer>
  <capture>
    <file name="live.jpg">
      <source>
        v4l2src  num-buffers=1 
        ! videorate !  video/x-raw-yuv,framerate=\(fraction\)3/1 
        !  ffmpegcolorspace ! jpegenc
 ! appsink name=sink
      </source>
    </file>
  </capture>
</gstreamer>

Those with a keen eye will notice that the live.jpg is generated with the same thing you can use in gst-launch to create a jpeg image. The final element is an appsink which is where libferris gets the bytes from. I made that last element explicit because you can tee the data in gstreamer and do other things to have multiple end points.

Then to take a photo and put it up on the net:


$ fcat     gstreamer://capture/live.jpg >| /Card/tmp/out.jpg
$ ferriscp gstreamer://capture/live.jpg 23hq://monkeyiq/upload

Of course, the fcat line above hints that you can use ssh to grab an image from the n900 to your laptop or server and upload it from there. See the ferris-capplet-auth for how to authenticate with the web sites and also how to have libferris scale before upload (optional) and what privacy settings to add during upload.

Next up is using the vimeo and youtube mounting in libferris to stream video to the net.

n900 goodies: unison, gphoto, working soprano, libferris, sixdof, coreutils, xerces3 et al

2010-09-20T17:52:00.000-07:00

Some goodies for the n900 are now in my repository. Yes, I know it's evil to have my own, but if that's all it takes to be George Thorogood then so be it. In the at the aforementioned link you will find unison, gphoto, stldb4, libferris, ocaml, a compiled install of coreutils to avoid battling busybox, xercesc, xalanc, xqilla, and a (more) working soprano.

I'm a tad surprised that unison hasn't made its way into the main repositories yet. I can't imagine that outsiders like me are the only ones who use it or want to. If you follow the "only one me" assumption then unison works well for providing bidirectional data syncing. I have compiled unison without a GUI under the assumption that you will be starting the process from the laptop or other more endowed machine. Although unison is written in ocaml, you shouldn't need to install that to get the unison package going.

The coreutils is just a compile and DESTDIR install wrapped up into a tarball. Shove them into /opt somewhere and prepend them to your path and magically df -lh and other normal commands work again.

I have ported libferris to xercesc3 finally, so I had to package that for maemo5 too. Which explains the xml packages. I put xalanc and xqilla there too so I can play around with xsltfs:// and XQuery on the device. It's powerful enough for these things so why not do them ;)

Once I installed libferris on the device I discovered a strange crash. Long story short, the soprano on the device was using redland as it's backend, and redland was defaulting to using its hashes backend (Berkeley db) which wasn't available. So the current soprano works only with memory models it seems. Though support for sqlite is compiled into redland it isn't the default for soprano persistent storage. What is stranger is that db4.2 was already on my n900. So all of this could have gone away if redland was compiled with db4 support (which happens automatically when the db4-dev package is installed before compiling redland). To see if your redland will work with db4 run these on your n900... The first works if SQLite is supported, the second will fail if you do not have berkeley db4 support compiled. The redland (librdf) from my repository uses libdb4.2 on the device to enable the second command to work properly.


$ rdfproc -s sqlite myrdf add \
  'http://witme.sf.net/libferris-core/0.1/myrdf-so2p.db' \
  'http://witme.sf.net/libferris-core/0.1/start' \
  'http://witme.sf.net/libferris-core/0.1/base'
rdfproc: added triple to the graph

$ rdfproc -s hashes myrdf add \
  'http://witme.sf.net/libferris-core/0.1/myrdf-so2p.db' \
  'http://witme.sf.net/libferris-core/0.1/start' \
  'http://witme.sf.net/libferris-core/0.1/base'
rdfproc: added triple to the graph

So now the fun part starts, using libferris to "copy" images from the camera to flickr, mounting the sqlite databases on the device as filesystems, gluing the geolocations markers to those created on the desktop and other data/filesystem games.

n900: The new device!

2010-09-15T03:16:00.000-07:00

Last week I got a wonderful surprise in the mail, a tasty new n900! The package "from" lists Quim Gil as the sender, so its come directly from half way around the world. Thanks Quim! And now for my initial thoughts and investigations; some of this will be of no surprise to existing owners, some of it was of some surprise to me. Oh, before I begin and loose folks to the down arrow key, anyone know of plasma packages for the n900? I'd like to port my abomination australian weather plasmoids over for mobile use.

Firstly, the device feels much faster than the n810. I'm not sure how much of this to attribute to the 50% faster clock of the CPU, the new GPU, differences in the ARM core itself or differences in software stack optimizations.

I should mention that during installation I found a few warts and issues here and there. Overall I really like the device, please don't consider the following criticisms as my only thoughts on the device, but given a limited amount of time with it so far, these bumps are still on my mind. Good points and comments about libferris on the n900, efl apps, accelerometer fun, and other hacking will likely follow once I get scratchbox up and running in a 32bit ubuntu vm.

As a filesystem guy I noticed a few rather nasty warts off the bat. A little constructive criticism for the new device?

Firstly that MyDocs is vfat, which I discovered when trying a good old ln(1) invocation. This is fairly easy to fix, and its now an ext4 filesystem. Soft links aside, the shared map tile cache gets put into ~/MyDocs/.maps by default, and I've seen some reports of bad internal fragmentation arising if that has remained vfat.

The temptation for btrfs was of course there, but for now MyDocs and /MemoryCard are ext4. That brings up the second thing I noticed, plugging in a new sdhc card, it was mounted and offered right off the bat. But if you mkfs.ext3 on that card (and change it to the right part type), the n900 doesn't want to know about it. There are fixes for this, mainly hacking /usr/sbin/mmc-mount to accept partition type 83 (Linux) and mount it "auto".

If you start hacking with partitions and whatnot, make sure you peek at and probably mangle /usr/lib/genfstab.awk to be smarter. I'm not sure using awk for creating /etc/fstab is a gain here. Especially inferring /home and ~/MyDocs based on partition type. Filesystem labels might be a wiser choice if lvm is not sought. I mention this because I managed to get the device into an endless reboot cycle which I suspect is due to it not finding the right filesystems early in the boot. As /opt is on /home and stuff gets shoved into /opt to save space on / (which is /usr too) then not finding /home might have some negative impact during boot.

For now I just made a more solid entry for /home and ~/MyDocs in the BEGIN block. Device boots up fine, is vfat partitionless and has goodness of ext3 and ext4 filesystens.

I then spent a bunch of time getting syncevolution to be happy. The result is I now have contacts and events from desktop, laptop, e71, and n900 all syncing. The issue that frustrated me was that the n900 was dropping timezone info and just calling imported events GMT. Of course this winds up shifting events in the calendar off by your UTC offset. For now, forcing syncevolution to use the older text/x-vcalendar format to hand to the n900 works around this issue. But it took at while to find that one out. Thanks to the syncevolution guys for their quick responses to my bug report. To get things clean, I need to move the report to the respective software that handles the data that syncevolution offers the n900.

I have KOffice installed on the n900 and abiword. The former brings RDF to the device and the later will soon join its ranks. Rich RDF cut and paste anyone? There are some very interesting possibilities using office documents, RDF and an Internet connected device when on the move. But I need to get some more lines of C++ out of my head and into my emacs before I can show them in action.

Metadata extraction and segv

2010-09-08T01:09:00.000-07:00

This is a post about metadata extraction from files for desktop search. While it applies specifically to libferris, the same considerations apply to anything which trawls an entire filesystem looking to create a rich index of metadata to allow desktop search to run queries in a reasonable timeframe. Ferris runs fine on KDE and the n810 (soon n900?) so its applicable to both syndications in a way.

Back in January 2008 I released a version of libferris which allowed metadata extraction to be performed out of process. While this obviously means some context switching is added, it is not necessarily slower for it. It will likely be slower on a single core ARM chip, but on a four or more core desktop the processes can run in parallel and so might actually be faster for it.

I recently tinkered with this, moving to using QT for DBus inter process communications and activation. The design uses a worker interface which has simple get/set methods which take the URL and name of the metadata to fetch and return the data. The set also takes the new value to set.

There is a broker which sits between the client and the worker and provides an async interface and also allows more than one worker to be spawned and controlled without the client needing to worry or care about this. The broker has asyncGet which takes the same URL and metadata name, and returns a numeric ID for this request. A signal is then fired either for success (with value) or failure (without). A failure might occur when the file at the URL is corrupted and the library used to inspect it for the metadata crashed. This is of course recorded so it doesn't constantly happen for that file.

The upshot is that I can use libferris to view a directory and if the xine metadata plugin crashes, the file manager stays around and only the background dbus worker process crashes. This is not to pick on Xine, which is a great project, but if hacking on libferris has told me anything it is that there is always a file on the drive which has some bytes in a strange way that is unexpected.

Perhaps more interesting than the file manager, the file indexer can trawl through everything and will not itself crash when a strange invalid file causes a segv in metadata extraction. So partially downloaded (and failed) content in my ~/FromInternet folder will not halt the indexing process with a segv.

Using DBus with a simple interface like that also allows new metadata extractors to be shared more easily. It doesn't matter if Strigi, Tracker, Beagle, or Indexer Foo use C++, Qt, mono, perl or whatever, as long as they can offer two methods on DBus. Though some factory/activation stuff is also needed to let the indexers and projects know that metadata these plugins can handle.

For those who haven't hit the pagedown by now, the interfaces are in
DBusGlue/ferris_internal_metadata_broker_introspect.xml
and worker_introspect.xml in the upcoming release of libferris (ie, the one that will happen in the next week or so when I get a moment). The DBus processes live in the apps/metadataserver of the libferris tarball.

The broker interface looks like this:


    <method name="asyncGet">
      <arg type="s" name="earl" direction="in"/>
      <arg type="s" name="name" direction="in"/>
      <arg type="i" name="reqid" direction="out"/>
    </method>

    <signal name="asyncGetResult">
      <arg type="i" name="reqid" />
      <arg type="s" name="earl"  />
      <arg type="s" name="name"  />
      <arg type="ay" name="value" />
    </signal>

    <signal name="asyncGetFailed">
      <arg type="i" name="reqid" />
      <arg type="s" name="earl"  />
      <arg type="i" name="eno" />
      <arg type="s" name="ename"  />
      <arg type="s" name="edesc"  />
    </signal>

Yubikeys and KDEs

2010-08-27T21:41:00.000-07:00

The yubikey is a small usb flash drive like device which can generate a one time password on demand. When it does this it inputs it as though it were a usb keyboard. You can set your own keys on the device and authenticate yourself locally using OTPs which is useful as well as cool.

A little series of hurdles later and I have the key unlocking KDE4. Some of the issues you are likely to see are that /etc/yubikey needs to be +rw by whatever is trying to use it. So making a yubifoo group and setting /sbin/yk_chkpwd to be setuid that group can be a plus. The biggest problem I had was trying to get the YubiPAM module to unlock KDE. It turns out that it was getting the user name and sending that to a child yk_chkpwd to verify instead of sending the current auth token.

To fix it, you might like to mangle pam_sm_authenticate() to use the following to get the authtok and send it through as the one time password for verification...


const char *prompt = 0;
const char *authtok;
int rc = pam_get_authtok( pamh, PAM_AUTHTOK, &authtok, prompt );
if( rc == PAM_SUCCESS )
{
  otp = authtok;
}

REMOVE these two lines which don't seem to work


otp = get_response(pamh, "Yubikey OTP: ", verbose_otp);
retval = pam_set_item(pamh, PAM_AUTHTOK, otp);

With this in place and the normal line in /etc/pam.d/kscreensaver:

auth sufficient pam_yubikey.so

the key should unlock you, or a regular password too. If you want two phase then it is easy to hack that into pam_sm_authenticate() looking for a pin prefix inside the authtok. Breaks the rules of module stacking in PAM, but works as they say.

To setup an offline aes key, make one somehow and use


ykpersonalize -o fixed=$modhexwhatever -a $aes_key_here \
 -o -static-ticket -o -strong-pw1 -o -strong-pw2 \
 -o -man-update

ykpasswd -d $my_user_name
ykpasswd -a $my_user_name -k $aes_key_here \
  -f $modhexwhatever \
  -o OTP

ykvalidate -u $my_user_name OTP

where OTP indicates a tap of the yubikey.

You can also get a layer down from ykvalidate using


echo -n OTP |  /sbin/yk_chkpwd $my_user_name

There are other groovy scripts around to lock the screen when the yubikey is removed from the machine which might be a nice next step... now that it actually works to *un*lock.

Conferences...

2010-07-26T22:55:00.000-07:00

For those who haven't done seen it, linux.conf.au now has its CFP open, till 7th Aug. It was quite a tight window this time around, but if you already knew about the conference, you probably already have something to pitch to the call :)

IMHO it would be nice to see RDF/Nepomuk folk(s) and some maemo/moblin/i-rebrand mobile hackers too. So please excuse the dual syndication on the premise that some hackers might not have noticed the CFP but have cool stuff which just might be made cooler by chatting over a few beers in 30C summery weather.

Winning the West...

2010-07-20T22:43:00.000-07:00

This morning I discovered that the UPS had played games during the night and my server was thus off. Turns out the machine endured a hard power drop complements to the APC 1500 UPS. I must say, less than impressed is a euphemistic rating for that particular rack mount UPS. On the other hand, the little 620VA APC unit I have works fine.

Anyway, so the server didn't want to boot, one of the XFS filesystems was wedged. Setting aside the fsck.xfs == nothing glory, at times you do need to xfs_repair. I've hit this once before, having to repair and zero the metadata log to regain mount ability. No log zeroing was needed this time it turned out.

The trick here is that during booting of a Fedora machine, if a local filesystem complains during fsck -A loud enough then you get offered a root shell assuming you have the password. Unfortunately, every character typed seemed to be taken as the password, so if root has a password of length > 1 char then you can't login this way. And with 20 local filesystems and no indication of which was the problem this makes for hours of bliss. Forget rides in the mountains, nice scotch, or a good book, Russian roulette with fsck is the edge of the seat fun way to spend a few hours.

Anyways, having a 4gb live Fedora USB stick helped. Having access to rpms for XFS helped too, and those were extracted and installed on the USB stick should the need arise again. For those finding this through the libferris internet searches, the command you are after is

rpm2cpio foo.rpm | cpio -id

to extract the foo.rpm to paths relative to the current directory. Though if that command escapes you then having a wedged ext? or XFS not permitting you to boot up would likely be an epic problem. FWIW I also managed to wedge btrfs into a charming state recently due to a non UPS backed power failure. This is not a slur on any of these filesystems. Trying to get performance and durability in the face of arbitrary hardware and firmware paths is not hard, its rock hard^TM. There is no substitute for a good UPS if you care about your byteses.

Take the Wrather With You...

2010-07-10T16:08:00.000-07:00

If anyone in the maemo world knows of recent plasma packages for the n810, please drop a line or leave a comment linking to it from here.. The post is about Abomination, my perl/KDE4 code to grab and log data from the Australian Bureau of Meteorology and present it in an interesting way.

I notice that doppler wind is now available from the Australian Bureau of Meteorology. Also, I didn't notice the up to 512km composite rain maps before. The plan is to include support for both of these radar types into my KDE plasmoiods. I think having the doppler wind as a transparent overlay above the rainfall overlay would be quite telling, being able to see why clouds burst at given points.

Though this doesn't solve the deeper, more interesting question of if the system that is causing the interesting wind trend will remain for the next 2 hours while you are outside performing activity-Y and wanting to remain dry.

Perl io::all, REST, and libferris, wagging the dog

2010-07-04T00:36:00.000-07:00

A feature that I've had planned to add to libferris since the UKUUG spring conference earlier this year is Perl io::all support. I've syndicated this because adding an io:all interface to KDE kio stuff would also be very cool IMHO.

I'm digging around for others who think io:all is cool and perhaps that libferris is "plus neutral" and might have some time to help out with the creation of a CPAN module to let the two things work together. In libferris there is a single shot interface to get metadata or file content as a single std::string or an std::iostream based interface allowing seeks, streaming and all that jazz. Ultimately I'd like to make the streaming stuff meet perl::io and also have a fake hash there to allow EA to get read on demand. The C++ and to a fairly large extent the Perl binding side I have knowledge of. But I admit to mostly being a Perl user rather than developer of the language or CPAN modules.

If anyone has pointers to stuff that would help out doing this stuff (tutorials and the like) or would like to support the feature in other ways please drop me a line or comment here. Otherwise, I'll probably dig into this later this year, time permitting.

I'm also thinking about making a REST server for CRUDing libferris. This should make Web clients much simpler to create, for example file managers in Yahoo widget UI. Once again, if this interests you, feel free to jump on in ;-p I'll have a survey of existing REST apis for this sort of stuff, obviously providing a similar interface will help other clients to interface. Luckily I can reuse some of the knowledge I gained when mounting web services as filesystems in the creation of the libferris web service server.

Meritocracy, Fate Or Anarchy

2010-06-26T16:05:00.000-07:00

Many folks on a higher pay grade than mine tout that open source thrives as a Meritocracy. In this model, folks who are interested enough create a project and release the source under GPL/Whatever and if the project is "good" or "gooder" than other ones it has more merit and will advance to become more widely used etc. One interesting counter point to this made by Alain de Botton in his TED talk where if this rise due to merit, then things also sink due to it. Alain is not talking open source, but if we switch to that context, then if your project is not becoming successful, or you are struggling, then the Meritocracy eye balls would see that since you created the project, by implication you are scum.

During such talks of open source, I have to remove myself from the direct discussion. My hubris is not quite up to the task to extrapolate my situation, be it good or bad, to the larger context.

However, I have seen other people who have single handedly created fairly complex projects over many years only to have large corporate sponsorship arrive for other offshoot or fairly recently created projects. In this case I often wonder that it really doesn't seem that merit has much input into the funding decision. Of course, some will say that to talk about open source and funding is crass, if you like to do it then you will regardless of the open fingered gloves and dynamo powered netbook. But seriously, if a project gets 5-10 full time paid developers, are you confident you can "compete" with that, for 6 months, 3 years, 10 years? Or is it the case that more or less your project has been swept under the bridge by a corporate funding decision you were not even aware was happening?

Another good example of this is the Linux distributions who want a project for "Y" and decide to create a solution themselves rather than trying to adopt something that a committed developer has been working on for years. In some cases the "owning" the code can be more important than reuse, and most often the code is released under and open source license. But this be a fairly vicious demotivator for folks who were writing the existing "Y" solutions.

The specific examples of these sorts of things that I've seen over the years have led me to wonder what sort of model open source really follows. It does seem that Fate or Anarchy are most close to the process at times. Fate particularly coming into play when a developer is at a conference and happens to bump into the guy who works at a company who might be funding a project in a similar area soon. This angle has implications for open source conferences and CFPs in general. If you are not living in Europe or the USA then you will have a lesser exposure to conferences in those spheres and to some degree your project will have less chance of success, no matter what the code does or how well. While many conferences have a travel budget, where you are living will be a factor in whether your project Y or somebody else doing Y2 will get to talk.

Unfortunately these thoughts do not really have a strong conclusion. I thought I'd throw it out there a long with a few TED links to try to brighten up some a few folks who might have read about open source as a meritocracy and started to feel gloomy. Another interesting and related TED is by Dan Pink.
And all ya'll might like the metated which lets you grab talks from a single link source. Its really just an XML file with direct links and metadata, so if your downloader doesn't like it, emacs and wget are your friend.

redrum a distro: rm -rf /Fedora13

2010-05-31T01:55:00.000-07:00

Some discussion recently came up as to what the outcome of a "rm -rf /" would be on a Linux machine. It's been ages since I last tested, and at the time there was no LVM in use, and /dev was actual nodes instead of a virtual filesystem. So, I was installing Fedora 13 64bit to test some hardware out and couldn't resist "seeing what happens". Needless to say, its not going to be an outcome that is pleasant, but academically interesting perhaps. If you don't know what the command does, don't execute it! And probably, don't even if you know what it does ;)

Also, I ran this from a gnome-terminal under a normal graphical session.

The filesystem layout was:


Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/mapper/vg_test-lv_root
                      51606140   3111784  45872916   7% /
tmpfs                   769704       548    769156   1% /dev/shm
/dev/sda1               495844     28538    441706   7% /boot
/dev/mapper/vg_test-lv_home
                     560152184    203192 531494900   1% /home

The home partition still contained /home/whiteele/.gvfs and the root lvm had var/lib/nfs/rpc_pipefs and empty boot, dev, home, proc, selinux, sys directories. But other than that everything else was eaten by the rmrf. Oh yes, and you have to supply the --no-preserve-root option to ensure the rm command that you know you are being silly.

Libferris and flickr, vimeo, facebook etc.

2010-05-28T04:30:00.000-07:00

If you don't read Linux Format, issue 133 and 132 have some good material on how to mount web services as filesystems using libferris.

Plasma, libferris, and Google Spreadsheets

2010-05-14T17:19:00.000-07:00

In my previous post I talked about how libferris now has a Plasma DataEngine which lets you get at the entire virtual filesystem (on demand) from plasmoids.

I've since extended things so that the DataEngine now includes a Service object, allowing plasmoids to write data too. Instead of tracking an XWindow, this time around I'll track a Google Spreadsheet and update it through the plasmoid. Doing this makes a mounted web service like GSpreads into a pastebin with access control applied. So you can share your clipboard with anyone in your "group" or company and stop others getting at it.

The two plasmoids show two spreadsheet cells, the top one is the top coloured cell and the bottom plasmoid is the lower, purple cell. The purple cell in the spreadsheet is the sum of the three cells in the column around the peachy cell above it.

First, updating the spreadsheet through the browser is reflected in the plasmoid. Towards the end I copy and paste a number into the top plasmoid, which updates the peach cell in the spreadsheet, which in turn causes the purple cell to update and so the lower plasmoid shows this updated sum. Of course, these two plasmoids don't have to be on the same machine. For tracking sums or other formulas, the ferris_graph might be more interesting if you are more interested in the trends than the current value.

plasma-google-spread.avi from Ben Martin on Vimeo.

Plasma & the libferris DataEngine

2010-05-12T23:30:00.000-07:00

In a previous post I mentioned that libferris can now mount Plasma DataEngines. Of course, the opposite would have to follow; you can now access the entire virtual filesystem of libferris as a Plasma DataEngine. For those who are unfamiliar with libferris, it is my little virtual filesystem project which can mount xml, isam files, relational databases, flickr, vimeo, google spreadsheets, Firefox, XWindows, and shall we say one or two other things :)

To play around, I now have a DataEngine that ships with libferris itself (which exposes libferris to plasma), and a few custom plasmoids which basically ask the libferris data engine to "cat" files and metadata.

One of the things that libferris can mount is the XWindow system. This lets you see all your windows and their size and location. This data is exposed in xwin://localhost/window and the Extended Attributes (EA) x,y show the x and y position of each window. For example, the below command will show you the name and location of the window "foo" on your local X:
fls --show-ea=name,x,y xwin://localhost/window/foo

The libferris data engine makes "sources" on demand. You ask for a source by supplying the URL you want to read, the data engine makes the source for you and the content key contains the contents of that URL. If you want to get at metadata through the EA interface, just use @attribute in XML fashion.

The two plasmoids I made are libferris_cat and libferris_graph. The former just shows you text of the URL you have configured, the latter allows up to four files to be read and graphed. Obviously the latter plasmoid is meant for numeric data.

So to see the location of a window with ferris_cat set the URL to:
xwin://localhost/window/foo@x

Which is what I've done in the below video. Notice that there are two plasmoids so I can track the X and Y ordinates of the window as I move it.

plasma-cat-window-position-encoded.avi from Ben Martin on Vimeo.

The same data is shown using ferris_graph below.

plasma-graph-window-position-encoded.avi from Ben Martin on Vimeo.

Libferris can also mount postgresql and other relational databases. For postgresql you can run SQL and execute database functions through the filesystem as well as interact with the base tables. Lets assume you have a simple database like the one shown in the below setup:

drop database testplasma;
create database testplasma;
\c testplasma

create table folks ( name varchar, salary int, id serial );
create view stats as
select min(salary) as min, max(salary) as max, avg(salary) as avg
from folks;

insert into folks values ( 'Fred', 15 );
insert into folks values ( 'Mary', 17 );
insert into folks values ( 'Henry', 21 );

select * from stats;
min | max | avg
-----+-----+---------------------
15 | 21 | 17.6666666666666667
(1 row)

To get at this with libferris you might start by probing around the pg:// or postgresql:// URLs:

fls pg://localhost/testplasma
folks stats

fls -0 pg://localhost/testplasma/stats
15 21 17.6666666666666667 17.6666666666666667-21-15 avg-max-min
Adding the --xml switch to shows something including:
avg="17.6666666666666667" max="21" min="15"
name="17.6666666666666667-21-15" primary-key="avg-max-min"

Because the view has no primary key, libferris has used the values of the whole tuple to form a unique file name. This is less than optimal for our needs when using the DataEngine because we want a stable filename. The solution is to leave out the name and just use "*" to have libferris expand it for us! So the below URL will have ferris_cat track the "min" value in the view:
pg://localhost/testplasma/stats/*@min

The below video shows ferris_cat on the left viewing the min, the ferris_graph in the center shows min, max and average, and the avg is shown in the ferris_cat on the right. I add and remove a few folks from the table to see the effect on the plasmoids.

plasma-ferris-postgresql-encoded.avi from Ben Martin on Vimeo.

Of course, for a production PostgreSQL server you would use a scratch table and triggers to update it so that aggregates are not computed over mid to large sized tables all the time. Another advantage of triggers and a scratch table is you can easily handle rolling averages and delve into more advanced statistics while keeping the overhead known.

In short, if you can ferrisls and fcat something interesting, you should be able to drop it onto your desktop and monitor it now too :) All I need now is to get plasma onto my n810 :/ I have a feeling I'll be playing with tracking facebook and online spreadsheets using plasma+ferris soon ;p

Desktop Annotations...

2010-05-08T16:42:00.000-07:00

OK, so a post about annotating files and desktop search. KDE guys might be interested because libferris uses soprano, the base of RDF on that desktop, maemo guys might be interested because all this works on that platform too, and I have a specialized index structure for n810 power level devices in libferris.

Tagging and Annotations are closely related. Tags (or emblems in libferris terms) are great for assigning one or more concepts to a file.
Annotations are great for adding some free text to something. While a short annotation might seem like one, two, or three tags, as in the example below, annotations also carry linguistic weight. Normally with tags you don't care about the order the tags are added to the file. With an annotation and a full text index you should be able to do proximity matching and ordered searching "seed collection" matches but "collection seed" doesn't. There are also issues of human language stemming which many tag systems silently ignore but full text indexes tend to have to address.

Below is the ego file manager 0.30.0 with the Annotation side panel. This panel auto saves the annotation if you select a new file or if you stop changing it for a few seconds. Hotkeys make this all quite handy. I'm using Control-t to start interactive tagging and Control-6 to switch to the annotation sidepanel with focus in the text block there. Hitting tab in the annotation sidepanel moves focus to the file list, so you can skip to and from annotating each file without the rodent.

You can of course add, view, and edit these same annotations from the command line. The fedit command runs vi on the annotation, allowing you to freely change it.
I have just fixed a slight inconsistency in the fedit command so it now accepts the "-a attribute" option too. The fcat views the annotation "-a attribute" from the file.

$ >| tfile
$ fedit -a annotation tfile
...
$ fcat -a annotation tfile
hi, the new annotation

$ feaindexquery '(annotation=~new)'
Found 1 matches at the following locations:
file:///tmp/tfile

Another nifty trick is to see the annotation right inside an fls output. Use mtime-display if you want the time to be more human readable than an epoch time_t.

$ fls --show-ea name,size,mtime,annotation tfile
tfile 0 1265954823 hi, the new annotation

Remember also that fls --xml gives you XML output, so with an XSLT stylesheet you can serve a directory of files and their annotation through your web server.
If this is of interest, see apps/phpsearchinterface/xml-results-to-xhtml.xsl for an initial stylesheet with row colour striping. It should be easy to extend the stylesheet to present other attributes. Bonus marks for anyone who makes it handle arbitrary XML attributes and orders them according to a predefined POSET. Patches always welcome...

When libferris saves an annotation, if DBus is enabled a signal is emitted on the session bus: "org.libferris.desktop", "AnnotationSaved"
which carries the URL and Path for the file you changed. This allows not only reindexing to happen, but you are free to hook up some Perl or whatnot to monitor this signal, then you can actually run some logic to work out what to do. If an annotation is saved, you might like to update an RSS feed for example.

And so ends the libferris tip of the day... happy annotating!
This post has been fueled by 99% cocoa, thanks to Jan-Piet Mens ;-)

Plasma: Tree Shaped Eyes

2010-05-06T00:05:00.000-07:00

After digging into KDE4's plasma a little bit it smelt a bit like an old friend. In Plasma you have one or more data engines, and each engine can have many sources. Each source offers a list of key-value pairs, which are updated at a nominated interval.

Normally folks think of filesystems as directories and files. But these days, you have to consider the Extended Attribute (EA) interface that filesystems offer as well. This makes a filesystem much closer to a large XML repository than just a collection of files accessible through a tree namespace (the directories). In libferris, each EA key-value pair can also tell the developer/user what schema that value has. This closes the gap between what a filesystem is and what a plasma data engine is just a little bit more. In fact, one might think of a plasma data engine as a virtual filesystem with a touch of extra stuff to allow a plasmoid to poll the data engine easily. This is not to detract from plasma at all, saying its "just a filesystem" means it is like postgresql, xml, or emacs to me ;)

For example, to see some current weather using my ABOMiNation plasma data engine and libferris (dev trunk), I can see the wind and also what type of value that EA or data engine key-value is:


$ fls -l \
  --show-ea=name,air-temp,wind-speed,wind-gust,schema:wind-gust \
  plasma://abomination_observations/nnn1

nnn1    22    15    26    schema://xsd/attributes/decimal/integer/long/int

One major upshot of looking at plasma in this way is the major upshot of everything being a filesystem. I can "cat" values directly from a data engine and also use fls to inspect data engines and their values from the command line while developing. plasmaengineexplorer is very nice, but its a bit of a pain to use a GUI tool to test out if the data engine is working when you are in a compile, run test cycle. It is also really easy to pluck out data from plasma with libferris, for example, the above fls with a --xml on the command line will do what you imagine. And if you are a nepomuk fan, using fls --rdf will give you an RDF/XML file to enjoy.

I found a few of the data engines would crash if they are started with a QApplication that forces GUI to off. So I black list
s == "tasks" || s == "mouse" || s == "keystate"
in order to mount plasma at the moment. Also, I'm using the signal/slot callbacks to get at the source key-value hash because the immediate mode methods don't seem to want to work for me :/

Plasma: Environmental Awareness

2010-04-27T20:11:00.000-07:00

Last time around I mentioned the plasmoids I finally decided to write to show information from the Australian Bureau of Meteorology, or BOM as it's lovingly known in some circles. I have put in place a few more touches to make it useful and have been experimenting with it since the last post. Shown below is the updated radar view which uses a custom background image and a modified locations overlay. The sat images are from Google Maps.

This gave me the idea that this particular plasmoid should be "Environmental" instead of just weather. If there is a crash on the north bound road that you use, seeing a little red dot there would be great. Having it pulse when you animate the radar would also be good so you have a much greater chance of seeing it. Likewise, for bus and train services, seeing which lines of interest are inactive due to track work or where delays are. It is more about showing things that are of interest today than just the weather.

I'm thinking that using Marble and Nepomuk (RDF) here would be the way to go. Telling marble that the doppler radar images are for dlong/dlat and extend to dlong/dlat should be OK for overlaying them. Nepomuk would be the way to go for harvesting the other information, like the delays or traffic reports and if they are properly geotagged, perhaps geo84, then a sparql should be able to bring them to the map. Of course, a timeline slider would then live on the top so you can see things that might have happened but been already resolved.

My mind's eye could see the benefit to the gust / average wind speed vs time plot plasmoid, but now that I have had it running for a while I can also show folks that I wanted... as you can see, looking at the plasmoid on the right, the red is the average wind speed and the blue extends to the gust speed. It becomes obvious not only if it is breezy, but if there is a large amount of variability in the wind. This metric is very important to some activities that are sensitive to wind. For weather geeks, the drop in wind should also show in the temp graph on the left because the apparent temp will alter as well. Though at 16C with winds < 10km/h it is to small to really see. BTW I know that the times are wrong in the title, there is an erroneous UTC offset happening to that epoch somewhere along the lines it seems.

I am not fully happy with the Forecast view. The icons and max temps for today and tomorrow are shown on the left and the detailed text on the right. It is very hard to show the detailed BOM text graphically, as things like "Chance of a late storm" require strange combinations of the "Fine" and "Storm" icons from the KDE set, and that doesn't take into account the "chance of" part in the text forecast.

These will likely be shoved into KDE's svn as aaron suggested. If anyone feels strongly _against_ that choice then please ping me, otherwise I'll assume sunshine and lolly pops.

Plasma: It's an abomination I tell's ya...

2010-04-26T04:57:00.000-07:00

Now that I have your attention and defences up, abomination is the name of my new plasmoids for showing the Australian Bureau of Meteorology (ABOM) National weather info, thus it is an ABOMiNation. Yes, my humour is offered for free, though you die a little with each joke.

Things are split up into Perl scripts, data engines, and plasmoids. Its still version 0.0.1 so expect a reading of the README and a bit of tinkering to get going.

One of the nice things is that the radar image loop can be offered on the desktop with just the latest doppler radar overlay. As the background, topographic and locations are all separate PNGs you can easily get a custom look and feel or theme for your version too.

Observations are downloaded for your nominated cities. The observations plasmoid can show the ambient and apparent temperature, wind average and gust speeds, and rainfall on a rolling graph. These screenshots were taken with a sample time of 1 second and a random multiplier to test, in reality you should see nicer bell like curves for temps and less sporadic curves for wind. Seeing the gust as a cumulative on the same graph is handy for motorbike riders so you can see how "choppy" things are at a glance. Especially if you have observations for other places that you are heading towards which might be 100-200km away from your abode. For temps as shown below the -1 as the offset to apparent temp from ambient temp. The time is always when the latest observation was taken.

As you see below, the blue area is the gust speed above the average. So a variable wind will show up graphically. The direction is shown in the title along with the average and gust relative to avg speeds. I particularly hate the weather applets that show the direction as an arrow, and wind speed as a smaller number. Chewing up screen for something I don't care about and not showing detailed wind observations.

As this was my first foray into KDE applets, I found the many tutorials on DataEngine and Applets to be a good start, but there are still times when you have to RTFS and grep the subversion to work out how to do things. I still have another plasmoid to write but a release will happen very soon. I infact tried kde-apps.org today but its interface is annoying so I'll likely shove it up on sf.net in the next few days.

Looking for some coding work...

2010-04-23T17:21:00.001-07:00

If you are on the lookout for a C++, GTK+2, Qt, Linux developer with a PhD and experience in persistent storage and indexing then I'm looking for you!

For those who don't know me, I am "the libferris guy". Which means I have played with virtual filesystems for many many years and implemented a good handful of ways to index and search diverse filesystems. Some of the articles I did for Linux Journal and linux.com will give an impression of the sorts of things libferris can do, and in the next months the Linux Format includes information on Web services as a filesystem, eg, mounting flickr, youtube, and facebook.

After hacking RDF support into KOffice earlier this year, I would very much like to work more with Soprano and RDF technologies. But anything involving indexing and storage is also of huge interest. In fact one of the things I like about RDF at the low level is that it overlaps these desires too, for example, my custom model partial implementation for Soprano which is targeted at great performance on embedded devices.

I have implemented some GIST trees for PostgreSQL and worked with C++ and development on a Linux platform for over 10 years. If you are interested in these things or just want a Qt hacker for a while then please drop me a line using the nick for this blog at gmail or sourceforge as email address.

Nepomuk & Social Networking: The Golden Opportunity

2010-04-08T16:44:00.000-07:00

After reading an article on Boxee recently which described it's social network integration it occurred to me how wonderful this would be to have for KDE. Having tags and ratings on the desktop is a really nice thing, but having tags and ratings coming through for arbitrary pieces of information from your "friends" makes things quite interesting.

From the Boxee example, why can't I see that Fred has also scheduled to watch Program-X. At the moment such recommendations are handled by many folks through IM or email, which is quite kludgey to say the least. There is no simple click to record or accept a recommendation, you have to mentally context switch to the TV schedule and update.

One thing that makes this all come together is not thinking of tags or ratings as binary or a single 1-5 range. To quote my own code, if a tag is able to also record the thoughts of many actors as a range, say a double from 0-100, and each actor has a level of trust associated, then the system itself can infer that if Fred is watching something and it is rated SciFi then automatically I want to take a peek too. By allowing tags and ratings to capture more complexity behind the scenes, the computer can infer more for us, and part of that can be a traditional 1-5 rating or whatever... hey, I work on virtual filesystems, is it really that strange that I would want to virtualize file ratings too?

The big gain here is if KDE itself can provide the spine for this. In my own system I stopped short of being able to automatically distribute these tag and file ratings. Surely they can be sent to other libferris systems and integrated, but that process, and the one of tracking friends and assigning privileges to them is not 100%.

Combining RDF with the social network element is an interesting chance here IMHO. Perhaps a central server of sorts is only really needed for tracking the privileges and assigning friends, and a p2p protocol can then be used to actually transmit the RDF you have decided to share to your associates. Though a fully central server implementation would probably provide a quicker starting point. As an upside, this would allow syncing RDF between many of your own devices -- tags from the desktop appearing on mobile devices when the VPN is up.

Of course, information sharing would have to be explicitly condoned by the user, and public key crypto would be needed to ensure integrity, privacy, and authenticity etc.

This sort of thing extends nicely to audio and image apps like Amarok and KPA. If I give somebody a copy of some images I took of London, when I add tags, they should also trickle through the system to them. If they are looking at a photo of the Wigmore Hall I took, they might like to know more about that place, and perhaps which CDs I have of chamber music from that trip.

This is something I'd love to hack on when I get the chance. In the meantime I thought I'd drop the idea here in case there are other folks who are also interested and we can combine forces.

Can't get there from here

2010-03-06T00:15:00.000-08:00

I've been thinking for a while about an application for mobile devices that knows rail, bus, ferry, and magical flying eagle timetables and stops. The idea is to be able to glance at a mobile device and see it say "hey you are at foobar, its 9pm, I guess you want to go home/to hotel, and here's how you can do it, how regularly that happens and the last time you could do it today".

Of course, n900 guys will want to just use a web service for this. But as mobile data costs kidneys in some parts of the world, I'm more inclined to choose a design that precaches the data when free wifi is available. This also plays well for travelling with roaming charges etc.

If you are travelling, then the machine should already know where you are staying and when, so it can direct you to the metro line of interest from where you are to get there. Again for travelling, being able to wangle a timeline to move "now" forward and see that the app can suggest reasonable options as it goes is also a good idea. You don't want to rely on it to suggest and then find you are late for the jet.

I'm thinking perhaps Qt/Soprano for this, but the exact RDF vocabulary for the bus, train, etc timetables is not jumping out at me. There are many adhoc designs I've thought about, like a series or RDF list of ical entries for each bus run, perhaps with each entry using geo84 or some other ICBM assocation method. If you know of a good RDFS for this, please let me know. I don't know when/if I'll get to hack on the code, but the itch to do so is unlikely to go away by itself.

Everything is a filesystem. Everything is an emacs buffer.

2010-02-26T00:26:00.000-08:00

I finally started hacking on TRAMP to add libferris support. I notice that in 2009 GVFS support was added to TRAMP which is very cool. I was originally poking around the lisp sources for the various things that TRAMP can use as a virtual filesystem when a fairly clean design hit me. Instead of bringing TRAMP to libferris, why not do the opposite?

So I started digging into the 8,000 odd line main tramp.el file and tracing ssh connections to see what commands were executed in the background. The plan being to add any of the POSIX commands that tramp wanted which libferris didn't already have clones of. It turns out there weren't too many, mainly ftest and fstat. These are needed to poke around and obtain details from the filesystem in order for tramp to know if things exist and more information about them. The twist of course if that much of the "stat" data is not available for some libferris filesystems. For example, an element in an XML file might not have a proper octal access mask, or indeed any explicit user/group information.

I currently have load/save working for subelements in XML files, and keys in an ISAM file like a berkeley db4. The patch to tramp itself is around 10-15 lines. Much of this can be abstracted out so you can nominate to use "the libferris command" instead of the normal coreutils one. eg, using fstat instead of stat.

$ fcreate --create-type=db4 --rdn=isam.db .
$ date | ferris-redirect -T isam.db/subfile1
$ db_dump -p isam.db
VERSION=3
format=print
type=btree
db_pagesize=4096
HEADER=END
subfile1
Fri Feb 26 18:24:55 EST 2010\0a
DATA=END

And to edit the subfile1 inside that berkeley db file over the network:
$ emacs "/monkeyiq@myserver:/tmp/isam.db/subfile1"

For performance, it is handy to play with version control and how backup files are made. The later is actually quite important for editing part of an XML file, because you can't have "elementname~" as a valid element in an XML document.

This works OK, but having the backups on the local machine is even faster.
(setq backup-directory-alist
'(("^/[a-z]*:monkeyiq@myserver:.*"
. "/monkeyiq@myserver:/tmp/.saves")))

And now to get editing data from postgresql happening too, and oh, editing a buffer in an emacs process on a remote host which is mounted by libferris?

Five Star General

2010-02-20T01:59:00.001-08:00

I've been thinking about proxy patterns a Soprano lately. It seems like a great idea to create a Soprano::Model shim which logs mutable operations to an SQLite database. This would allow intermittent syncs between devices, so a maemo device could have a full local mirror of RDF and communicate with your laptops, servers and desktop machines to keep semantic knowledge in sync.

There are a bunch of nice little edge cases which make this deceptively complex. bnode handling for one changes the rules because identity must be preserved.

I'm not sure if/when I'll hack on such functionality, but I thought I'd blog about it in case somebody else is also kicking around the same ball :)

Libferris: now and then...

2010-02-14T16:28:00.000-08:00

Those who have been following libferris developments over the recent years will have noticed that I switched over to using Soprano for RDF support in 2009. I also added support for mounting relational databases (using QtSql) and converted the http and ftp mounting over to use Qt for network IO. This later point also extends to the support for mounting flickr, vimeo, google spreadsheets and docs etc. So Qt is slowly marching closer to the "kernel" of libferris.

I've been toying around with switching over some of the core parts of the libferris kernel to using Qt. Things like using Qt's smart pointers instead of the policy based ones from Modern C++ Design, switching over to using Qt signal/slots, and perhaps offering both iostream and QByteArray data access methods in parallel.

There are a number of "smaller" tasks to support this. For example, creating a stldb4 like library allowing access to Berkeley db4 and other ISAM files with a "Qt native" style API. Stldb4 only supports bdb files, whereas allowing other ISAM like gdbm, tdb, and WhateverDB to be accessed through the hypothetical QISAM library would be nice. If anyone has recommendations along these lines please drop me a line or leave a comment. I mention smaller in quotes above because I know this task is quite difficult to do well, things like ordering and prefix ordering of keys come up as well as support for secondary indexing and other goodies which are really needed to milk performance out of custom ISAM solutions.

The harder part would be porting over the core kernel of libferris to Qt stuff. As it would be extremely hard to do piecewise it would require a contiguous block of free time. It is also a fairly hard thing to try to get financial support for because the only "feature" it adds is the possibility of ports for other platforms. My point of mentioning this is that at some stage, libferris ports for Symbian and other Qt supported platforms will become much simpler. Finally I could "cp" an image directly from the camera of my s60 phone to flickr without the annoying third party apps.

As an aside, I was wondering how long it has been since I started using RDF on the desktop. The November 2003 version 1.1.12 release mentions mounting RDF... so it's been a while. RDF is extremely handy for separating data access from personal metadata. If you want to add an extended attribute to a read-only NFS share, with libferris and RDF you can, and you just use the same API as normal ;)

KOffice and RDF: Say it with Style...

2010-01-25T05:58:00.000-08:00

This scattered series of posts has been about the RDF support I'm working on for KOffice. The ODF document format lets you store RDF/XML data inside the document file, which in turn lets both a human reader and a computer know about things that comprise an office document. You can refer to a person, place, or time and have the computer know what you are saying without having to resort to heuristics.

Having RDF support in document formats means you can send somebody a single file containing exact information about real world events. The RDF can contain details which can be pulled up in the formatting of the text that you see. For example, for a given contact you might know his phone number, home page, normal business location, email address etc. You might only want to see a small fraction of this information at one place in a document, but perhaps for a header you want to know the postal address too. Stylesheets are what I'm working on right now to let that happen.

At the start of the video below, you can see James, Joyce and Mark. As I click on these contacts, the RDF docker tells me information about them. As you can see, there is more information known to KOffice than is shown in the document (first & last name). However, for Mark, we also know where he is and that is shown in the RDF docker.

James is mentioned in the second paragraph, and the document is talking about giving him a call to verify something. Instead of hunting down his phone number, you can set a semantic stylesheet for that particular reference to him in the document to include is phone number inline in the document text. The added advantage here is that if you edit his phone number via the RDF docker, all the places in the document text that cite the phone number are updated for you. KOffice knows that those digits are James' phone number, so it can modify them for you.

Later on we again cite the event itself, just saying its "next weekend", which isn't an ideal description of when a specific event is happening. Luckily, we have cited the RDF event, so it shows up in the RDF docker and the stylesheets are available to reformat the text. In this case I want to see the summary and when it starts.

I'm working on adding user specified stylesheets now too, as the Format menu shows in the video. When you create a user stylesheet it is also saved in RDF, so the stylesheets you make become part of the document itself. They will be available when some other KOffice user loads the document.

The File/Document Information widget has a new RDF section which lets you see and directly edit the RDF triples if that's your thing, the semantic tab shows you all the higher level things that KOffice has seen in the document, like poeple, places, and events, and finally the stylesheets page lets you nominate how you want things formatted by default. For example, you might want to see a persons name and phone number so setting that to the default lets you then drag and drop some contacts from kaddressbook into the document and you will see the phone number as part of the document text.

Of course, you can drag and drop items from the RDF docker into kaddressbook and korganizer. These pieces of information should be able to be moved into and out of an ODF file using KOffice without thinking about it. You want to add Fred to the text, pick him up from your kaddressbook and drop him into the RDF docker. Your default contact stylesheet is then used to insert some text into the document at the current cursor location showing you the Fred contact. Quick and simple... Lets make RDF something everybody uses but nobody needs to learn about (unless they want to).

KOffice and RDF: Say it with Style... from Ben Martin on Vimeo.

KOffice & RDF: Who, What, When, Where?

2010-01-02T00:40:00.000-08:00

As mentioned in a previous post, ODF documents can contain one or more RDF/XML files. These files allow you to unambiguously encode information for both computer and human consumption. So you can describe a person in a way that tells you their phone number and also lets the computer know that these digits are a specific person's home phone number. Common data formats like vcard and ical have some encodings in RDF and soon a KOffice near you will understand these pieces of data from ODF files.

KOffice currently understands some of the FOAF vocabulary (storing contact data), and the rdfical format (for events). There are a few ways to encode longitude and latitude in RDF. The current patch supports two of them, with optional linking to rdfical. This is one of the major strengths of RDF, you can say who, where and when and also link these things together so an event carries not only a time but its location information too.

The below video shows the new RDF docker in aciton. As you click on text that has associated RDF, the docker shows you the interesting information. Frodo and Sam are assoicated with both traditional contact data and a location. The items in the RDF docker let you import them into your system (into kaddressbook or korganizer) or export them to well known desktop formats like vcard and ical. Editing locations is done with Marble and there is only a minimal set of information for contacts and events currently. Note that mid way through when I edit an event, timezones are respected. If the RDF describes an event as being in Tokyo, that timezone offset from your current localtime is respected.

Towards the end of the video I show that contacts can be simply drag and dropped between koffice and kaddressbook. This also works for events to/from Evolution but I had some issues with korganizer for events. D&D makes KOffice and ODF quite a convenient format for transmitting semantic information to colleagues in a single, self describing file.

KOffice & RDF: Who, What, When, Where? from Ben Martin on Vimeo.

This blog post message was filtered by the Australian Government.

2009-12-18T02:19:00.000-08:00

This blog post message was filtered by the Australian Government.

Office documents that mean something?

2009-12-05T01:38:00.000-08:00

I've been hacking on the development branch of KOffice to add RDF support. Thanks to KO GmbH for this chance! This means that while a document can posit a linear progression of characters and words like normal, the software can start to understand a bit of what you are talking about too.

The ODF document specification allows RDF to be included in the document zip file either inline in the main content.xml file, or using manifest.rdf and other RDF/XML files in the zip. The RDF is free to refer to XML elements in the content.xml, so you can add metadata to names, places, times etc so that a computer can work out unambiguously what you are talking about. This makes an ODF file a very powerful container format for transmitting meaning to people.

At it's heart, RDF represents all information in triples. Bob knows Alice, etc. See lwn.net or other sources if you want to know more about RDF. But you don't have to know it to use it with KOffice ;)

Below you can see that I've hacked the "Document Information" window to let you see the raw RDF if you want to know exactly what is going on:

If on the other hand, you are not a developer and/or don't really care about triples or RDF, there is the Semantic view. Right now I only have support for Contact information which is drawn from the FOAF RDF vocabulary. If the later doesn't mean anything to you, its just a way to describe people and their relationships using RDF. As you can see, you don't have to care about RDF here, you just see people. Right clicking on a person lets you do things like import them into your contacts database, or, in the future, other things like email them or phone them.

While it is nice to be able to have contact information extracted from the document, it is much nicer to have KOffice know exactly where that information relates in the document. For this I have a new Docker for RDF as seen in the below video. First you see that the addressbook is empty. Then I start moving the cursor around in the document. Notice that the docker picks up when the cursor is on the name of a person that has RDF metadata. You see more information about Frodo, and then I import Sam. The contact entry in the addressbook created for the import brings his phone number in too, which was part of the RDF but not explicitly shown in the document.

KOffice starts getting RDF from Ben Martin on Vimeo.

I hope to add support for other things like times, locations, and relationships. This way you can send somebody a document describing a meeting and they can import the time into their smart phone directly from the document... can we make retyping such information a vague memory like punch cards?

Clawmotia, look and feel and portrait mode

2009-11-12T23:39:00.000-08:00

Clawmotia is a remote control for MythTV using Qt and qedje. The claw works on maemo and desktop systems. I have updated submenus to fade better, added hotkey support, and improved images and icons since 0.2. Grab it at my maemo repository.

In the shot of it running on the device shown below, the euro sign is for commercial skip forward and back. Having the skip back in the top right of the device makes it very easy to hit if an auto skip has gone too far. It is no accident that pause, mute, and cancel are placed in the other corners. The icons below change the volume up and down. In the middle of the top is an icon to bring up a submenu letting you set the aspect ratio and stretch the video in various ways to get maximal use from your screen.

I have also been tinkering with allowing switching between landscape and portrait mode, the edje is ready, there are just a few things to iron out before it works as expected. Of course, such switching will be far more useful on an n900 where it can happen automatically as you rotate the device. But for n8x0 users a button will be available trigger a rotate...

Improving the CLAW!

2009-11-08T03:30:00.000-08:00

Clawmotia is a MythTV remote using edje and Qt. It works well on maemo, desktop and other devices. It requires a MythTV Web setup to talk to. See previous posts for how to set it up.

I got rid of the rendering artifacts on maemo, added hotkey support (volume, fullscreen) and some of the buttons on the main remote screen now bring up submenus. This paves the way for more advanced remote control configurations where intricate but rarely used controls are still available on the remote. For example, aspect ratio and image fill are unlikely to be needed on a well setup MythTV installation, but they are in a submenu of the remote should they be needed. I know the backgound for the submenu panel is not really nice, but with the drop shadow and pan in effect (which also needs tweaking) you can easily see it's a submenu.

Grab it here. I've included the x86_64 and armel binaries as well as the edj "edje" file. You'll need QtCore and qedje and you're in business. For the mameo you'll still have to make a menu shortcut yourself, and of course, see the README.

Better artwork very welcome. If you have skills, I should be able to take an xcf file and turn out a theme. Conversely, take a look at the edc file and you shouldn't have much trouble adding/removing buttons and changing the images.

White lightning in triplicate

2009-10-31T19:54:00.000-07:00

Recently I started hacking on a memory mapped, multi_index soprano backend. While adding triples, and using listStatements() should work fine, implementing SPARQL is making for interesting times.

I started out allowing a single triple match with a filter(regex()) to restrict results. And this worked rather well, making the first one free as they say. So, noticing the little white rabbit that seemed to disappear into the SPARQL bushes, I decided to join in the high tea and mercury sniffing that so induces sanity. Over the course of version 0.0.1 to 0.0.5 the SPARQL code is becoming better, little by little. The code is up at my sf.net page. But don't blame me if the your SPARQL is not implemented yet or your triples somehow disappear.

Anyway, here is a little benchmark session. I'm using the data set generator and queries found here. To make the data I use


$ cd /usr/local/java/bsbmtools
$ cat run.sh
#!/bin/bash
java -cp bin:lib/ssj.jar benchmark.generator.Generator "$@"
$ ./run.sh -fc -pc 1000 -s nt
$ mv dataset.nt  thousand-prods.nt
$ mkdir -p /tmp/RDFBENCH
$ cd /tmp/RDFBENCH
$ mkdir mmap redland

Queries are run multiple times to ensure a hot disk cache. This is on a 3 disk RAID-5 and an Intel Q6600 with 8gb RAM.
The last query is not optimized properly in boostmmap yet, so its far slower than it rightly should be. For benchmarking the boostmmap backend...


$ cd /tmp/RDFBENCH/mmap
$ time sopranocmd --backend boostmmap \
  --serialization ntriples \
  import /usr/local/java/bsbmtools/thousand-prods.nt >|out 2>&1

real    1m49.642s
210M     triples.mmap*

$ time sopranocmd \
  --backend boostmmap \
  list "" '<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>' \
  '<http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/vocabulary/product>' \
   >| /tmp/out 2>&1

real    0m0.103s
grep Product /tmp/out | wc -l
1001

## based on Query 6
$ time sopranocmd \
  --backend boostmmap query \
"
select ?what ?lab
where
{
  ?what http://www.w3.org/2000/01/rdf-schema#label ?lab .
  filter( regex( str( ?lab ), 'excites' ))
}"
?lab -> <yawned%20excites%20deflower>;
  ?what -> <http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/instances/productfeature295>
?lab -> <goofs%20excites%20enigmata>;
  ?what -> <http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/instances/productfeature3276>

real    0m0.091s


$ time sopranocmd --backend boostmmap query \
"
prefix bsbm: <http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/vocabulary/>
prefix xsd: <http://www.w3.org/2001/xmlschema#>
prefix dc: <http://purl.org/dc/elements/1.1/>
select ?offer ?price
where {
    ?offer  bsbm:product http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/instances/dataFromProducer1/Product5 .
    ?offer  bsbm:vendor ?vendor .
    ?vendor bsbm:country http://downlode.org/rdf/iso-3166/countries#ES .
    ?offer  dc:publisher ?vendor .
    ?offer  bsbm:price ?price .
}"
0.93sec

Note that this 0.9seconds is shameful and needs to be optimized back to <0.1sec.

For redland,


$ cd /tmp/RDFBENCH/redland
$ time sopranocmd --backend redland \
 --serialization ntriples \
 import /usr/local/java/bsbmtools/thousand-prods.nt \
 >|/tmp/out 2>&1

real    38m34.735s
480mb

$ time sopranocmd --backend redland \
  list "" \
  '<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>' \
  '<http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/vocabulary/product>'  \
  >| /tmp/out 2>&1

real    0m0.096s
grep Product /tmp/out | wc -l
1000

So for just listStatements() redland and mmap are fairly equal in performance. Which, for a single indexed lookup, you might expect. In libferris I had restricted RDF usage to raw triple probes like this because I used redland directly prior to version 1.4.x of libferrris.

So for SPARQL,


## based on Query 6
$ time sopranocmd --backend redland query \
"
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
select ?what ?lab
where
{
  ?what rdfs:label ?lab .
  filter( regex( str( ?lab ), 'excites' ))
}"
what -> <http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/instances/productfeature295>;
   lab -> "yawned excites deflower"
what -> <http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/instances/productfeature3276>;
   lab -> "goofs excites enigmata"
real    0m3.855s

Gah, and I didn't slip up and put the 3 on the left side of the dot there. We are talking about 0.1 seconds for boostmmap against 3.86 seconds for redland.


$ time sopranocmd --backend redland query \
"
prefix bsbm: <http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/vocabulary/>
prefix xsd: <http://www.w3.org/2001/xmlschema#>
prefix dc: <http://purl.org/dc/elements/1.1/>
select ?offer ?price
where {
      ?offer bsbm:product <http://www4.wiwiss.fu-berlin.de/bizer/bsbm/v01/instances/datafromproducer1/product5>
      ?offer bsbm:price ?price .
      ?offer bsbm:vendor ?vendor .
      ?offer dc:publisher ?vendor .
      ?vendor bsbm:country <http://downlode.org/rdf/iso-3166/countries#es> .
}"
real    0m7.134s

Since this query doesn't work well on boostmmap it only goes from 1 to 7 seconds. But I think I can resolve it in much much less time than 1 second. This is not meant to make redland look bad, it's SPARQL implementation is much more complete than boostmmap will likely be any time soon. Creating an optimal query plan for the full SPARQL language will be an interesting challenge.

Development might be bursty as I don't know what time I can spare for improving the SPARQL completeness in the short term.

I give you the CLAW!

2009-10-31T18:15:00.000-07:00

Clawmotia, an edje MythTV remote control.
Sources hot off the presses: clawmotia-0.0.1. You'll also notice the diablo binary for clawmotia on there so you don't need a scratchbox to get going. I put the clawmotia.edj up too so you don't even need to compile that if you don't wanna.

Dependencies on the device: Qt, qedje. You probably have most of the requirements for the latter installed if you have canola2 on the device. There are deb files for qedje on its web site. Qt is also packaged for the n810. I don't have debs for clawmotia yet, feel free to send the debian directory to do that.

You'll obviously need a MythTV server (and client) to use the remote. It uses the web interface to mythtv so you'll want that installed on the server machine too. The various configuration settings are passed in using environment variables in version 0.0.1. See the script start-clawmotia.sh for these settings. You will also need to be in the same directly as the .edj file when you start clawmotia as it expects that at this point. I install the script, binary and edj into /usr/local/bin on the device.

Setting CLAWMOTIA_FS=1 will start clawmotia full screen. There is a bug in version 0.0.1 where it will start but not be shown if started full screen. You have to switch to another app and back to clawmotia to see it. I was planning to fix this before release, but it seems some folks want to have a tinker with it so I'll fix that bug soon.

If you want to change the buttons or layout, you only need to edit the clawmotia.edc file. If you are good with the gimp, you might like to reate a theme at 800x480. As long as you use layers it should be a fairly mechanical process to create an edc file for your theme.

To make a button, define its image in the images section and call the three macros COMMAND_BUTTON, COMMAND_BUTTON_ICON, and COMMAND_PROGRAMS. COMMAND_BUTTON sets up the area of the screen that will react to your button with an optional text label for the button as arg2. COMMAND_BUTTON_ICON links a COMMAND_BUTTON with an image file. And COMMAND_PROGRAMS links a button with the exact, HTTP encoded string to send to the MythTV server. HTTP encoding doesn't effect single keys much, but Ctrl+w becomes Ctrl%2Bw. The first argument to all the three macros is the button name and should be the same for the same button. Taking a look at what is there and remembering to use all three macros to give (a) initial setup, (b) image file, (c) action should get you one the way.

You can update the theme by compiling it with edje_cc and copying it to the device. The application itself shouldn't need any changes.

Note that the bevel buttons are separate to the actual button function image. So if you like you can remote the button by setting 255 to 0 in the lines
color, 0 0 0 255
in the COMMAND_BUTTON definition in clawmotia.edc

I'll probably move to cmake or autofools at some point. If, on the odd case that there are many patches flowing in, then I'll throw the code into subversion somewhere.

The Rasterman has recommended cloning a few hardware remotes as themes. I'm not sure when I'll have the time for that but it should be interesting.

Oh yeah, and if you like this then you feel free to contribute toward a memory card or IR transmitter for my future tinkering. Or send any old n900's you have laying around ;) Hey... I can dream right?

I want my MythTV: Clawmotia

2009-10-29T20:58:00.000-07:00

I noticed that there are many packages which turn a maemo device into a remote control. Unfortunately, the MythTV ones I saw either didn't install or were not what I was looking for. Thus clawmotia was born yesterday.

I'm using edje for the interface and qedje to actually create the UI. The program logic uses Qt to talk to a MythTV server and send the commands to it. This relies on knowing there your server is, and what client you want to control which are both passed in as environment variables. Really simple stuff, but it works well.

You'll need the Web interface on the MythTV server machine too. The upshot is that you only need a wifi connection and you can control any MythTV client you want. No bluetooth or IR dongles needed.

As you can see, there are some nasty graphical artifacts on the buttons which I'm not sure if its the evas engine or something to do with qedje. The black parts on the buttons are not there on the desktop.

As it uses edje, you can create different themes and layouts, compile the edje on your desktop machine and just scp it to the device to change the layout and button functionality. Including cute little slide in and out panels for the more rarely used controls. Hopefully I can convince somebody with more artistic ability than me to do just that. Source will be released in the next few days.

Welcome to the machine...

2009-10-29T20:24:00.000-07:00

Warning: this is a hello p.kde post, so now I can read minds; the page down key never looked so appealing!

OK, so I've been working on filemanagers for "a long time now". Back in the days when the Amiga was hot and hardware memory managers were a wonderful thing that would make a segv not take down the whole machine. Over the last roughly ten years I've been hacking on libferris. In that time it has expanded from a virtual filesystem to include index and search, virtualized extended attributes, RDF support, FUSE and rsync support and other party tricks.

Those with a keen eye will be asking why I am on this KDE planet when libferris "competes" with KIO, Strigi, Soprano etc. I have quoted compete because there is no clear winner and looser in projects that you do mainly for technical enjoyment. And there is no reason that libferris can not be used in a mixed fashion with other projects.

The last major release of libferris moved its RDF handling from redland to soprano, so at least the triples can be freely intermixed between projects now. On that note, I've recently created a new backend for soprano to use a memory mapped file with multi indexing as the triple store. See the ferris sf.net page for the boostmmapbackend tarball. The backend is in early days, but I'll take it for a walk on the n810 soon to see how well it works in that environment.

I am planning on adding spatial indexing and other tricks to the soprano backend which I've used for my maemo libferris metadata index module:

libferris maemo audio search by regex on URL from Ben Martin on Vimeo.

RDF on the device

2009-10-23T05:49:00.000-07:00

I've started work on a memory mapped soprano RDF backend. Given that mobile devices use flash for their permanent storage, an RDF backend designed using primary storage algorithms should work well on maemo.

While the SPARQL implementation is "far from complete", it can already evaluate some common queries very very quickly. I have some triple matching and the ability to have multiple regex filter statements. Other filters and more complete SPARQL lanugage support should follow in time, as time permits... patches accepted etc and so on.

For those interested, see soprano-boostmmapbackend on my main sf.net page.

Libferris, Soprano, Extended Attributes... the Ménage à trois

2009-10-14T05:43:00.000-07:00

If you want to store metadata in a filesystem, there are Extended Attributes (EA). The kernel interface allows you to store key=value metadata in these EAs for each file on your filesystem. The catch is that kernel EA are limited in size, sometimes performance is poor, and some systems do not support EA either natively or in the kernels that Linux distributions ship. The classic example of the latter is NFS, which can have EA support patched in, but many distros do not do that.

In libferris the EA interface is virtualized along with the filesystem. So if you are using XFS (or ext3/4 with the right options) then libferris will let you read and write EA to the kernel filesystem. For other filesystems, libferris stores the EA behind the scenes in RDF for you. The difference is no seen by applications, its all just EA... magically every filesystem supports read/write EA.

Version 1.4.0 and above of libferris use Soprano and optionally Nepomuk for RDF support. To take RDF for a spin from the filesystem lets use FerrisFUSE and the normal console tools...

$ mkdir -p /tmp/RDFTESTING/backing /tmp/RDFTESTING/fs
$ date >| /tmp/RDFTESTING/backing/df1.txt
$ ferrisfs -u /tmp/RDFTESTING/backing /tmp/RDFTESTING/fs

As you can see, backing is where the filesystem is and fs is where you can access backing through libferris. You could just as easily use a HTTP server or emacs as your backing filesystem, anything that libferris can see is up for grabs.

The below uses the attr command to set and get and Extended Attribute. Assuming that the /tmp kernel filesystem does not allow EA to be set by users. If in doubt, use an NFS directory and you'll almost certainly not be able to attr -s directly on the backing filesystem.

$ cd /tmp/RDFTESTING/fs
$ cat df1.txt
Wed Oct 14 22:33:04 EST 2009
$ attr -s foo -V bar df1.txt
Attribute "foo" set to a 3 byte value for df1.txt:
bar
$ attr -g foo df1.txt
Attribute "foo" had a 3 byte value for df1.txt:
bar

So, you might ask where does all this metadata go and come from. And what does the RDF schema look like... The best solution would be to use SPARQL to query the data, but the default store is still a redland one with libferris 1.4.0 and its sparql is very, very slow. 1+ minutes for a simple query on this data vs <2 seconds using the sesame2 soprano backend. So the fastest way to explore the redland RDF store is to export the whole RDF store and grep it for now. Hopefully virtuoso and/or my own soprano backend will save the day in the future :/

$ cd ~/.ferris/rdfdb
$ time sopranocmd --backend redland \
--settings name=myrdf export t

I have changed the URIs to use prefixes in the grep output... as you would expect, there is data attached to the df1.txt URL.

$ grep RDFTE t ferris:uuid ferris:93f22bd8-b8be-11de-8e06-001bfc4f043c .

That UUID node has an mtime and a out-of-band-ea bnode.

$ grep 93f22bd8-b8be-11de-8e06-001bfc4f043c t
ferris:93f22bd8-b8be-11de-8e06-001bfc4f043c ferris:mtime "1255523953"^^ .
ferris:93f22bd8-b8be-11de-8e06-001bfc4f043c ferris:out-of-band-ea _:r1255523601r5448r1 .

And the bnode has the EA foo=bar set on it.

$ grep r1255523601r5448r1 t
_:r1255523601r5448r1 ferris:user.foo "bar"^^ .

As you see, the UUID node has a mtime assoicated with it, this way libferris can tell if you have updated any RDF values for a file, and it becomes like an additional ctime check available to libferris and used for example when indexing files.

The gain of having the UUID node use a bnode is that many files can share the same RDF metadata. This is useful if you can access the same file from multiple paths or if files get moved on file servers and you want to relink the old RDF metadata to the file with the new path. I mention file servers here because libferris will track the metadata for you if you use ferrismv/ferriscp, but if somebody moves a file on the file server you've got to have a way to tell libferris about that change.

Fileserver movements are a common enough thing that libferris can automatically relink RDF nodes for you. There are also smushing tools available to help with the task. But that's a story for another post.

libferris 1.4.x - Nepomuk!

2009-10-13T03:52:00.000-07:00

So finally RDF handling is done using Soprano (The core of KDE4's nepomuk RDF library). Initially, ferris defaults to using redland in-process for RDF, so the code paths are very similar to what 1.3.x of libferris was using.

But the huge gain is that you can use the nepomukserver or the sesame2 soprano backends if you like. I'd also dearly love to write my own soprano backend, and am bashing out a design for it, but that's a story for another post.

I've run some initial benchmarks, and because much of the speed dependant code paths hit triples directly, giving S+P and looking up Object I suspect I'm not hitting the main benchmarked paths. For example, I've found that some SPARQL queries that perform set based S+P->O lookups run much faster on the sesame2 soprano backend.

Now if only OBS would hurry up, I'd have Fedora 11 packages of ferris 1.4.x available... but in the meantime, the steaming source tarball is on sf.

User overlay virtual softlinks

2009-10-08T23:36:00.000-07:00

This was introduced in libferris 1.3.8, The feature lets you have libferris create virtual softlinks for you when a directory is read. Overlay links are setup in the config file ~/.ferris/user-overlay-links.xml. The file sets up regex matches, when the regex is matched to a directory, a virtual link is created to a target location. The target location must actually exist at the moment, no dangling links are permitted. There is an example XML file in the dot-files subdirectory of the tarball.

For the gphoto:// filesystem I have this which creates the link G7 -> Canon PowerShot G7 (PTP mode) in the root of the gphoto:// filesystem.


<user-overlay-links>
  <link-by-regex>
    <vlink>
        <match>^gphoto:[/]+$</match>
        <target>Canon PowerShot G7 (PTP mode)</target>
        <link-name>G7</link-name>
    </vlink>
...

If the camera as a stable subdirectory that new images are written too, then a link right into that can be made in the root, "latest" takes me right to the images subsubdirectory.


...
    <vlink>
        <match>^gphoto:[/]+$</match>
        <target>gphoto://G7/store_00010001/DCIM/102CANON</target>
        <link-name>latest</link-name>
    </vlink>
...

It seemed like a good idea to abstract this out of any specific filesystem like upnp and gphoto so virtual links can be made anywhere. In particular, for upnp a/v devices sometimes the server likes to use an insanely long name for itself, with virtual soft links, the client machine can give the server a nice short name of it's choosing.

Race to do nothing!

2009-09-17T04:54:00.000-07:00

In the early days there was prelink as part of maemo. It disappeared in the n810 distribution ranges. I noticed that there is no armel deb in debian for prelink, but there were murmurs of folks hacking it to work. Push finally came to shove, and as I like C++ many of my apps on maemo have quite a few symbols that need to be resolved before the app can run.

The long story short, prelink_0.0.20090311 is up at my repo. Use at your own risk, if your device breaks you get to keep both pieces etc etc.

Initial benchmarking: for an app that uses a few libraries, is C++, and has quite a few symbols that the dynamic linker has to attend to. For a complete run before it was 5.2 seconds on a warm start, with prelink of the binary it is 2.5 seconds. Considering that in that 2.5 the app itself has to completely run, there was a huge amount of time spent, err wasted, in the dynamic linker.

Of course, if I can get hidden symbols to work too then that 2.5 might drop back to 1.5-2 seconds. But for hidden symbols you have to either wrap things in pragmas or declare each function and class as exposed or not, so for a large library its quite intrusive. But the prelink is a huge gain for no code changes, so far at least. YMMV.

It's a touch ironic that Nokia recommends using prelink for embedded devices. But that is for qtopia... maybe for the next distro prelink will reappear in the default installation.

geotagged image files and libferris

2009-09-05T18:58:00.000-07:00

Tip of the day, if you have a geotagged image file such as those produced using Location Tracker on Symbian phones, then you can use libferris to start Google Earth showing you that image on a map. Just run
ferris-open-google-earth-for-context.pl
with the image(s) you want to see. Its a fairly quick way to show the movements of the day on a map. I should also add timeline support there I guess, so you can retrace a trip in the order it occurred using just waypoint image files.

This also works with any type of file that is location tagged with libferris. If you have a digital long/lat then you can view it on a map (TM).

n810 and gphoto

2009-09-01T04:44:00.000-07:00

After noticing that gphoto is not packaged for maemo I did a bit of digging, seeing sad news from those who tried getting it going. But I thought I'd try with 2.4.6 to see if things are better now.

For those who want to tinker, see my packages. The library came across OK but gphoto itself uses a newer debhelper, so I just plucked the binary itself into the repo. If you want to use this with libferris, then expand the additional libraries into /usr/local/lib/ferris/plugins/context on the device.

I found that once USB mode was set to host, I could see the camera with gphoto but as reported in the past, there were frequent crashes. This is really unfortunate as all the blocks where in place for the command I was chasing:


# ferriscp -av \
 gphoto://Canon.../DCIM/102CANON/IMG_2442.JPG \
 flickr://me/upload

Most of the time using gphoto locks everything and about 5-10 seconds later the device restarts. I might have to hunt for a newer kernel for diablo... or wait until I have gphoto support on an n9 (nn?), a P+S wifi camera, and a decent data plan...

Images from n810 to the Web

2009-08-30T05:45:00.000-07:00

New debs allowing you to copy to flickr, 23hq, vimeo, youtube etc from the n810 are available. The next step is closer integration, tapping into the "send to" menu to let you send any image file to these places. Hey, its just a filesystem now ;)

One interesting possibility is using the n810 to shuttle images from a digital camera to the net. This gets around the vendor lock-in that might be present on your camera because the n810 just grabs the images from the cam and then shuttles them onward to wherever.

I also updated libferris to allow you to authenticate from the console, just the ticket to let you set things up over ssh with your desktop browser.

OK, for maemo, check the repository and you'll want ferris, libferris, and libferrisui at least. Version 1.3.6.
If you get into dependency trouble, see the build order to get an idea of the tree. Sorry its a bit hard to get on the device, hopefully stuff will move into extras in time.

Anyone who has used desktop flickr tools, you'll know about the whole authenticate before you buy thing. The below commands setup 23hq and copy an image over to it.


$ ferris-capplet-auth --list-auth-sites
...
flickr
23hq
...
$ ferris-capplet-auth --auth-with-site 23hq
...
Grant Auth following URL...

http://www.23hq.com/services/auth/?api_key=...

Then press return to continue...
<Open above link in browser, grant auth, hit return>

Done...

$ ferriscp -av 26082009071.jpg 23hq://me/upload

Hopefully things will become easier in the future: installation, setup etc. Of course, streaming from the webcam to youtube will rock, but baby steps as they say.

Them pesky web serviceses...

2009-08-07T04:52:00.000-07:00

It always stuck me as a little odd that you have specific applications to upload to flickr, another little app with a cute interface for throwing video files at webserviceY etc. I should also mention that all of this is coming to the maemo build shortly... what better place to unlock web services than a tablet or phone, neh?

What ever happened to the unix philosophy, "everything is a file". Then you could just "cp" to flickr, write your facebook status in bash or C-x C-s your mood to facebook://status.

I added some support for the flickr API to ferris last year, and the recent 1.3.5 release expands that and adds more web service goodness. But, which of these nasty, closed source services should be supported? The answer: it doesn't matter, there just filesystems! Of course, I'd prefer to mount a FOSS, GNU, Free, Privacy respecting server, and who wouldn't.. but for some things you want to just cp to youtube and forget about it.

For facebook I have three objects at facebook:// level. A status file which is read/write, a recent directory which shows the feed of stuff your chums are up to, and a contacts directory with virtual vcard files for your pals. I even added in the profile picture of each friend into their v-vcard. Unfortunately facebook doesn't allow you to get phone number info through the web API, which is strange because you can just simulate a login and swipe it by screen scraping, but that's nasty T&C violating thinking neh?

The flickr API mounting should work, to some extent with any service offering that API. For example, 23hq offers free hosting which might appeal. The extensions in libferris 1.3.5 let you see your contacts in a directory, find images by photo ID, browse your photosets and images not yet in a photoset. If you look in your contacts directory, you'll see their photostream and favs as directories.

Note that the thumbnail image is available from flickr through libferris as 32bit RGBA decoded data, so a libferris client can graphically browse a flickr API photoset just as it can a digital camera mounted with libferris. The thumbail EA is the same. Of course, if you copy an image from flickr:// or 23hq:// libferris grabs the largest (or original) image from the site and supplies it to you. Feel the unlocking of captive data. Oh, and upload works as it did last year...

Finally, the mounting of Google docs and spreadsheets. This also has support for appending to plain text files, so you can redirect stdout to append to a google docs text file just as you can >> /tmp/foo.txt.

Spreadsheet mounting goes right down to the cell. So you can use google as a calculator from the command line if it tickles you...


$ export SPREAD=google://spreadsheets/smalltest1/Sheet1
$ echo 5  | ferris-redirect --ea b $SPREAD/9
$ echo 23 | ferris-redirect --ea c $SPREAD/9
$ echo -n "=sum(B9,C9)" | ferris-redirect --ea d $SPREAD/9
$ fcat -a d $SPREAD/9
28

And there are vimeo, youtube and others still needing mounting... but thats what 1.3.6 exists for right? Feel free to send in patches for your fav service! See plugins/context/facebook et al in the source.

select...group by artist

2009-07-29T06:24:00.000-07:00

So I finally updated my Amarok mounting to work with 2.x. I'm still having a few issues with the 2.x of 'rok but that's another story.

One of the cool things about being able to mount things with libferris is that everything above ferris can also see them, XQuery, SQLite etc. For example, the amarok://playlist URL shows, as you would imagine, the playlist as it currently appears in the running amarok application.

The following little SQLite is fairly self explanatory:
.load libferrissqlitevtable.so
create virtual table fs using libferris(
'amarok://playlist',
'',
name text,
title text,
size int,
length int,
playtime text,
link-target text,
ferris-delegate-url text
);

select name, playtime, title from fs
order by name desc;

select avg(length) from fs;

And for a particular album, the playlist and average track time.

9|352|Absolutely Curtains
8|246|Stay
7|255|Free Four
6|274|Childhood's End
5|260|Mudmen
4|309|Wots ... Uh The Deal
3|187|The Gold It's In The ...
2|209|Burning Bridges
1|147|When You're In
0|185|Obscured By Clouds

242.4

Of course, a litttle group by artist, album... would make the SQL more generic:
select avg(length),max(artist),max(album)
from fs
group by artist, album;

285.777777777778|Pink Floyd|Dark Side of the Moon
242.4|Pink Floyd|Obscured By Clouds

Done bought me a new calculator...

2009-07-22T04:02:00.000-07:00

So, the next release of libferris will include support for mounting google spreadsheets. This works right through to the file manager now. You can mount a spreadsheet as a filesystem and edit it with ego. Changes to cell a written to google, any formulas that are updated appear in the file manager right away, and of course if you are viewing the worksheet in a web browser its updated too.

I'm looking forward to compiling the latest ferris for maemo so that you can edit stuff on the tablet and have it change on your desktop automatically ;)

export SPREAD=google://docs/spreadsheets/smalltest1/Sheet1
$ echo 5 | ferris-redirect --ea b $SPREAD/9
$ echo 23 | ferris-redirect --ea c $SPREAD/9

$ echo -n "=sum(B9,C9)" | ferris-redirect --ea d $SPREAD/9
$ fcat -a d $SPREAD/9
28

And of course, if you use the first row for headings...

$ echo -n result | ferris-redirect --ea d $SPREAD/1
$ fcat -a result $SPREAD/9
28

preupgrade -- caveat emptor

2009-06-25T02:47:00.000-07:00

A good rant every now and then?

I have been upgrading my Fedora machines by hand using yum. This seemed to work OK, for a machine with minimal tweaking there usually were not so many dependency issues that had to be solved by hand. Though it still is a time consuming process for a handful of machines.

So, I recently found out that I'm bad boy (oooh yeah!), and should have been using preupgrade. Looking at TFM I thought, "fair enough, upgrading a non live system seems like a wise thing". So I gave it a whirl. Which ended up in a strange exception in anaconda and after reboot /var/lib/rpm was missing. yay. So I trip to the reinstall Fedora 11 from DVD shops later and I was back in the mix. But there were/are still some other machines that needed updating to 11.

Once bitten, twice masocistic I thought. So I decided to try on another machine. It might have been something I tweaked on the laptop over the many Fedora updates etc that fluffed up preupgrade and anaconda...

Luckily the second time I didn't loose any data. For one thing, my /var/lib/rpm shouldn't be deleted assumption from before the first install was missing and everything was backed up (twice, I had running incremental baculas too). But preupgrade won't touch a system where /boot is on a RAID. So the second attempt stopped nice and fast.

I might try preupgrade again on the laptop next time. I left things fairly stock during the Fedora 11 install there just so preupgrade could possibly work its magic in the future. But I'm wondering if the pain of yum updating across versions makes sticking with Fedora worthwhile. I have better things to do than manually update and tweak things and if other distros don't chomp days of my life every 6-12 months then maybe I should check them out.

It's a bit sad that /boot on a software RAID-1 is such a rare setup that its not supported.

And that concludes this rant... was it as good for ya?

7th of May: A libferris talk in Ede, Netherlands.

2009-04-30T05:51:00.000-07:00

If you are in Europe and want to hear about libferris and other cool storage stuff (register &) drop by the
NLUUG Spring Conference on Storage on the 7th of May.

I will of course have a maemo unit running libferris there as well as a laptop. Carrying a server with ferris is a bit too much though :) I'm brewing up the slides now with XQuery, KML, and SQLite goodness. Probably not the first three terms you think of when the words Virtual Filesystem are muttered.

Keeping it sorted with libferris

2009-04-12T05:46:00.000-07:00

Click through for the 720 HD version...

Sorting directories with libferris and ego on multiple metadata values at once from Ben Martin on Vimeo.

This is the libferris file manager, it is called ego.

Although the interface looks quite simple, there
are context menus associated with most things.

There are also a vast number of sidepanels for searching,
filtering, bookmarks and editing metadata and tags.

Today I'm talking about sorting.

Of course, you can click a column to sort by it, and
click again to reverse the sort.

You can also set that sort order to be the default for
this directory, or the entire filesystem tree rooted
at this directory. Subdirectories will inherit settings
for a tree but can explicitly override them too.

You can also override what ordering you want for each
column, like using the version sort of ls for any column.

If you sort on something with many files having the same
value, you can append another column to the sort order.
For example, sorting by image width, then by file name
for files that have the same width.

You can sort by any number of columns. This is built
into libferris, so you can sort on many metadata fields
with ferrisls or any libferris client.

Packages for maemo and Fedora 10!

2009-03-22T02:04:00.000-07:00

So, long story short, the place I was hosting my maemo repository was on a host at the university I did my PhD at. The server has been suffering unpredictable hardware issues so I have now moved the repository. There is a new subdomain fuuko.libferris.com where I'll be putting up some libferris related stuff, including packages.

In particular, the new libferris maemo repository is now up.

Also note that I have binary rpm files for Fedora 10 in both 32 and 64 bit at OBS.

10: It's the way of the future; goto 10;

2009-03-16T05:41:00.000-07:00

So, boost 1.34.1 was released back in July 2007. It is however still the current boost shipped with Fedora 10. This is extremely unfortunate as there are many cool advancements in boost over the nearly 2 years since 1.34x. At least rawhide has 1.37, even though 1.38 has been released for over a month.

Looks like I'll have to add another switch to libferris configure.ac to drop some features to be able to compile against old boosts. めんどうくさい!

Like talking to a stranger

2009-03-01T04:33:00.000-08:00

Now that I'm on planet Linux Australia too I thought I'd write up a brief howdee post. My main open source project is libferris which is a virtual filesystem with metadata extraction and index+search functionality. It also does a bunch of other interesting stuff, but as I've been writing it for what is getting close to 10 years now, one would imagine it has a few facets.

I mainly package libferris for Fedora and maemo because these are the platforms I tend to use it with myself. A while ago I did some packages for openSUSE and Ubuntu, but its hard to keep motivation for those when I don't use the distro personally. Plus on modern desktop or servers, stuffing ferris on a virtual Fedora machine isn't much of a hassle, given the price of even DDR3 RAM.

I'm also trying to stuff libferris itself into the main Fedora repository. But we'll see how that goes.

If you want to hear about libferris and other filesystem crack then you should come along to this NLUUG event in May. I'll be there presenting libferris and what I think the intranet metadata and search stuff should be doing (and probably will be doing in the libferris world) over the next few years.

As my blog description states, my posts are mainly about libferris but also include maemo stuff and generic C++, XML, RDF, and relational database topics. I seem to waffle on unmerciful about indexing, or so I've been told. Which is hardly surprising given the chunk of libferris devoted to implementing filesystem search through various techniques.

Also, if anybody is looking for user space virtual filesystem hacking or index and search work, then drop me a line :)

Tracker: Reading it both ways :(

2009-02-28T04:00:00.000-08:00

Normally I refrain from criticising other projects that are "competing" with my little hobby -- libferris. I mention competing in quotes because hobbies don't really compete in a commercial sense. But having read this post recently on planet maemo about Tracker progress I was a little overwhelmed, wondering, was the Tracker code really so bad a year ago?

"In this last year, we refactor (well, almost rewrote) the daemon"

and talks about replacing the crawler code wholesale. Sure progress sometimes includes churn of functionality: reimplementing stuff with the benefit of 20/20 hindsight. But this seemed a little dramatic...

Slow as a tree

2009-02-28T03:54:00.000-08:00

Hmm, nepomuk integration as the core of amarok's collection manager... now if only flacs without seek tables were not so inconvenient in amarok it would be damn cool.

http://lists.kde.org/?l=amarok&m=120671838014374&q=p3

Finally it seems RDF is making its merry way into the core position of (meta) data sharing on the desktop. A good time to be a semantic hacker.

Keeping an index up to date... quickly?

2009-02-11T16:48:00.000-08:00

Most of the index engine implementations in libferris will detect when you try to add the same file again, and when it hasn't changed in a meaningful way will just skip reindexing it. This makes it really easy to just use the below command to update the index for a specific filesystem.

$ find /Data | feaindexadd --filelist-stdin

The trick comes in when /Data is an NFS share with 400,000 files on it that you are accessing from a Nokia n810. Or when /Data is a file server that you are indexing from your laptop over wifi or another sluggish, higher latency network.

feaindexadd can be told to directly traverse one or more directories and so you don't have to use find in the above command. But separating out the find from the indexing has a really big advantage: you can update indexes of extremely large, but infrequently changing NFS shares very quickly -- Even over slow networks.

The trick is to do the filesystem traversal on the server side, and just pump the URLs that are interesting to the client machine:

ssh lowaccess@server 'find /Data -mtime -10' \
| feaindexadd --filelist-stdin

Of course, this relies on /Data being the same filesystem on both the server and the client. Otherwise you're in for some fun with sed or awk to mangle the paths to be what the client expects.
And the 10 in the above means that you'll have to run the command from cron within 10 days to maintain a complete index. You might find that doing a "time find /Data" on the client and server has significant performance differences, particularly if the filesystem has many files.

You can always store and search the index from the file server, but for disconnected searching, you really need to have the index itself stored on the maemo device.

Searching indexes on a maemo device: a customized solution

2009-01-31T00:37:00.000-08:00

In a previous post I had a video showing one of the libferris inverted file metadata index plugins on maemo. Unfortunately that implementation was designed for a desktop machine, meaning for many many more files, slow disk head seeks, blazingly fast CPU(s).

While these videos are not as snazzy as some others, I make them so folks can get an idea of the real performance of the software. Saying its "acceptably fast" or takes less than a second is all well and good, but seeing the snail or rabbit move gives an immediate gut feeling if its "fast enough".

The new maemo custom designed metadata architecture uses the mmap() design. I always have my reservations about mmap() because it encourages data structure and algo choices that are directed at an in-memory world. That is all great if you can cache the entire memory mapped file in main memory, but often leads to kittens crying when there isn't enough RAM for that. For maemo with 128mb total RAM this is also an issue, but with the much faster disk seeks of flash storage the relatively poor data clustering of mmap()ed designs is a bit less important for performance. But of course, data clustering and physical layout is always interesting when playing the indexing game.

libferris maemo audio search by regex on URL from Ben Martin on Vimeo.

Shown in the video above is a search using the new "custom mobile device" libferris metadata index. As I continue to type a regular expression to match against the URL, libferris gives some search results on each character entered. Note that this is against an index with over 10,000 URLs in it. This index format will be available in libferris 1.2.7+. The index format sports a probabilistic regular expression prefilter for URL matching. This means that the results of the prefilter might include some false positives, but anything the filter drops out is definitely not a match. You have to run the regex itself on all results of the prefilter to drop out the false positives. The prefilter can drop the number of times a regular expression is evaluated down to less than 100 in 10,000 URLs given only a 3-4 character regex. This helps out oodles when you want to run raw regex searches on big (for a portable device) indexes and you want your results asap.

An unfortunate current side effect of the mmap() design is that the index is architecture dependant. Mainly because some secondary offset-pointer information is 64 or 32 bit width dependant, so its a matter of tracking those peskies down and clamping them to a fixed width. To get around that for now, I indexed the 10,000 odd audio files over NFS from an n810.

Some information for those looking to play, if you are using boost to memory map, you may well discover that atomic_cas32() calls __sync_val_compare_and_swap() which is not actually available on the maemo device (for me). This is with a modified scratchbox using gcc version 4.2.1.
I'm not sure if there is an accepted cas et al library for maemo/armel. I leave the hacks for __sync_val_compare_and_swap() to the reader and their accepted level of concurrency control risk.

Searching for audio files on an NFS share from maemo

2009-01-29T21:29:00.000-08:00

Searching for audio files on an NFS share from maemo from Ben Martin on Vimeo.

The n810 only has one memory slot. With an 8gb card in there you might fit 1,000 ogg files onto your storage. That was quite boaring, so I instead indexed an NFS share that is over 10x larger ;) I'm using one of the libferris inverted file backends for the index, which is more targeted at the desktop machine assumptions of having a faster CPU and expensive disk head seeks. Needless to say, I'm hacking on a custom index implementation for maemo which will be more oriented at a slower CPU with much much less expensive disk seeks for flash based storage.

Note that the time after I run ferris-music-search to when the first message appears on the console "Using index..." is fairly much all wasted in dynamic linking. A major slowdown that I've yet to sweep away for running apps on maemo.

The artist and title info is taken from the ID3 tags in the audio files. Indexing time is roughly 3 to 10 milliseconds per file when performed on the desktop. The inverted file index format is portable from desktop to maemo device. I plan to make the new explicit maemo format portable too, so you can make indexes on powerful machines and rsync them over to the maemo device. Assuming you are indexing stuff that is stored on your file server, not the maemo device.

During the typing for the first search on title, possible completions are shown by taking your input as a substring of the title you seek. This is more effective if you keep it in mind because you can choose just a few keys in a substring of the title. All searches are performed using regex matching on strings, which is much slower than direct equality because of the huge complications it introduces for indexing. But it is interesting, even with modestly 10x the number of files you can cram onto an n810, using nasty slow regex searching, the performance is acceptable for much of the time. There are a few cases that I'll improve, particularly regex searching on whole URLs.

Notice that the name and URL are shown as columns, so you can easily "group by" when you click on the appropriate header. I need to also include the artist, title etc ID3 fields into the results,. Oh, and have the ability to click on a few files and see the whole ID3 and metadata of those files "side-by-side" so you do not have to try to read it from the results list.

So now when I see a CD in the shops, I wont have to wonder how many of those Mozart tracks I have already, I can know for sure :-p

Accelerometers hit Canola2 and PDF viewing

2009-01-19T02:22:00.000-08:00

Of course, if a unit comes out with an embedded accelerometer in it then using a "slightly clunky" wiimote will no longer be needed as the source of motion data. I recently added the ability for libsixdof to control closed source applications as well as properly patched open source ones. This was mainly to let Google Earth finally take some advantage of proper sixdof devices, but it works equally well for Canola2 on maemo.

Controlling Canola2 using libsixdof and a wiimote from Ben Martin on Vimeo.

Two big features that libsixdof brings is the ability to configure what happens when the controller is moved on an axis, and how frequently that happens. So, if you don't like your images flicking past at 20 images / second in Canola, you can limit it to whatever / second. In the video, having maximum axis movement will only ever scroll 3 images / second. So when I hold the unit causing a continual next image movement I can still see what is happening and Canola2 does not get overloaded with events.

Flipping pages in a PDF by moving the n810 from Ben Martin on Vimeo.

Again the wiimote is actaully held behind the device. I'm sort of getting the hang of the controlling code etc so that you can use more subtle rotations of the device to issue commands to the running program. This is using the same stuff that the Canola2 video did, I could patch a PDF viewer, but for discrete events like next-page it doesn't really make a huge difference. Panning is the big thing that screams out for patching.

Like a walk in the park..

2009-01-18T17:27:00.000-08:00

A walk through the botanical gardens the other day with a digital camera and I had a nice little harvest of background images. Unfortunately the initial scale and crop of the scaled creature to 800x480 means his head is hidden somewhat under the status icons. But many of the other more generic ones work well for backgrounds. Plus I get the added bonus of having a collection of prescaled 800x480 images for demoing Canola hacks.

Didn't your n810 come with an accelerometer?

2009-01-14T19:53:00.000-08:00

Shown below is a video of the forthcoming 0.1.0 release of libsixdof with a wiimote. I have hacked up maemo-mapper to have initial support for libsixdof, I'll have to clean up the patch before letting other human eyes see it's nastyness :| I decided to use the C++ sixdof API which means there is a single C++ source file in my build of maemo mapper, it was just faster to get it coded that way. Perhaps I'll convert to the libsixdofc ANSI C API before sending the patch.

Didn't your n810 come with an accelerometer? from Ben Martin on Vimeo.

Although libsixdof supports other 6-degrees of freedom controllers too, getting those controllers to work on maemo is a little more of a challenge. For example, I would love to use the portable spacenavigator usb device with maemo. Even though most folks have the USB cabling to hook up the unit, and it gets detected by the n810 when you have USB in the right mode, getting XInput events from evdev on maemo might be another battle. It is not like that part is trivial on a desktop distro either right now unfortunately. I might end up hacking support for direct /dev/input/foo kernel devices into libsixdof to get around that issue and have "real" 6dof devices working under maemo.

Hello, planet maemo

2009-01-14T00:21:00.000-08:00

OK, so now I have relevant posts aggregated onto planet maemo, hi everybody </dr-nick>.

For those who haven't discovered it, I run a personal repository of packages for maemo. If you break your maemo device by using my repository, you get to keep both pieces. I have a few n810 units and of course my primary open source software suite, libferris, is ported to maemo and available in my repository. Libferris is a virtual filesystem which includes rich index and search capabilities. There are many nice choices for index+search for maemo, with Tracker coming out soon in the standard maemo distribution, strigi available for the n810 etc. Of course, I use libferris on maemo for my indexing ;)

My repo also contains a few handy misc packages like unison, sshfs, fuse, and tinc. Anyone notice the hints that I like filesystems? The unison package could be made to have a few less dependencies, but it works well already. I have compiled afuse, obexftp and obexfs for maemo but those are not in my repository yet because I'm having trouble getting the 810 bluetooth to work from the normal obex packages instead of through the osso-gwobex layer. It would be nice to be able to mount a mobile phone's sd card through FUSE on the n810 and share storage a bit more, but I digress.

You'll also notice cwiid and libsixdof added recently to the repository. I have been playing with a wiimote on the desktop and on the n810. The libsixdof on the 810 can read the state of the wiimote OK. The wmgui tool locks the CPU of the n810 at 100% when using the accelerometer mode, so clearly you have to be somewhat smarter about what you update for each event on an embedded device. I have hopes that I can hack maemo mapper to use libsixdof soon and thus be able to control it on an n810 using a wiimote ;) Getting other six degree of freedom controllers to work will be more of a problem on maemo because you need to use a very recent evdev with a patch for some devices.

One of the issues that still plagues libferris on maemo is the lack of prelinking. Starting an application that uses libferris causes the CPU to spend a bunch of time resolving symbols before it can start executing anything. I've enabled hidden symbols, compiled with a later gcc than the scratchbox normally uses and played games to speed things up, but getting close how quick a desktop machine can resolve symbols at application startup has still escaped me. I might end up rsyncing / to nfs:/foo and running prelink on an n810 just to see if/how much that helps things out.

Combine: wiimote, Google Earth, libsixdof and Linux

2009-01-13T21:07:00.000-08:00

Oh, and a nice seat, and you get another HID to use for moving around. This is using the upcoming 0.1.0 release of libsixdof which has wiimote support. Note that you can also use the spacenavigator true 6dof device. If you are using the later then you'll need evdev 2.1.0 or later, and if you're using 2.1.0 see this bug for a patch to get more than X and Y axis working.

More information to follow, including a video and details on the space navigator and GE.

libsixdof and a wiimote to control Google Earth under Linux from Ben Martin on Vimeo.

Chinook vs Diablo

2009-01-10T19:11:00.000-08:00

While most folks have upgraded to Diablo long, long ago, I fell into the trap of actually using the n810 early on. So I had a nice chinook setup and didn't really want to do the Wintel mantra of reinstalling just to get diablo. But now I've been playing with both, with two n810 devices, because its always more fun with two ;)

So one is running the Chinook from about Feb 2008 and the other RX-44_DIABLO_5.2008.43-7. I thought that wifi felt faster on Diablo, so I did a little measuring. Its quite slap happy but does show some considerable difference, using the same DLink DIR-855 AP for both devices.

On the server:
dd if=/dev/zero of=10mb bs=1024 count=10240

On the tablet:
time wget -Y off http://x/10mb

The results:
chinook:
real 0m29.301s
user 0m1.047s
sys 0m1.828s
350k/s

diablo:
real 0m24.815s
user 0m0.656s
sys 0m1.188s
546k/s

The chinook k/s is quite stable at around 350. On diablo things move around quite a bit in terms of speed. Perhaps this bursty nature works well for browsing making things 'feel' faster too.

2008-12-15T03:25:00.000-08:00

Welcome to the libferris screencast on copy append.
1) I start a copy from the command line.
2) I decide I want to copy another file to the same place.
For example to the same USB stick.
3) In the old days, I would have to start a parallel copy
or wait for the first copy to finish before copying
the second file.
4) Now, with libferris, I can just append it to the existing copy task for this destination.

Unfortunately the video quality is not so good in the final web version. Still some fun and games to be had getting things up to scratch.

Untitled from Ben Martin on Vimeo.

Automounting for the People

2008-12-10T03:16:00.000-08:00

Now that the bad pun in the title has been read, you can't unread it!

So, now libferris has some closer HAL integration. Of course, some might say right away that ferris has been able to mount dbus for ages, so why have an explicit hal:// filesystem. The reason is that the fdo methods in the raw dbus interface for HAL are very coarse, and by explicitly having a hal:// and a volume manager daemon you get some interesting possibilities.

When the daemon can't work out what to do, it runs a nice little wizard:

One you choose how to identify the volume, you can tell libferris what to do:

More actions will arrive in time. I particularly like the auto copy mode, if a usb stick is readable at 20mb/s, a local scratch RAID-10 at 200Mb/s it makes sense to start moving the data to the scratch RAID right away and then pick it apart from there rather than from the USB stick directly.

Libferris summer hackfest

2008-11-18T01:34:00.000-08:00

OK, so I now officially have one participant in the libferris summer hackfest! If you've been looking to help out a crazy filesystem project but hesitant as to who to approach, look no further... ;)

But seriously, if you have been using libferris and always wanted it to do X as well then now is a great time to help make it happen. Of course you could send patches, but you might be better off just buying some time and now is a great time to do the latter. And so ends the plugfest.

Unfsck your redland RDF.

2008-10-25T03:42:00.000-07:00

Again, for those who are using the unpatched db4 redland backend, if you get issues where libferris apps just eat CPU and seem to hang, if your backtrace includes Ferris::RDF::RedlandIterator::__advance() calling librdf_iterator_next() then there is a fair chance your RDF db4 files are screwed. You can try to recover them with the below.... sorry about the long standing issue folks.

#!/bin/bash

cd ~/.ferris/rdfdb

for if in myrdf-po2s.db myrdf-so2p.db myrdf-sp2o.db
do
echo "Fixing: $if"
db_dump -r $if >| dump
rm -f $if
db_load -f dump $if
rm -f dump
done

No n810 is an island

2008-09-14T21:33:00.000-07:00

Ch, Ch, Ch, Ch, Changes.

Yes, maemo has had rsync for ages. Yes, rsync makes dumping stuff to the device really easy. Trouble is, when you are travelling around for a while, and when you have a little keyboard you tend to update some of those files.

Assuming the OOM (Only One Me) rule, Unison is a great tool to make the n810 much less of a data island and more of an extension of the desktop.
Check out my repository for the debs. You'll need to install gcc and binutils, complements of the way ocaml is currently built. So thats another 15mb of downloads or 40mb of card space you'll loose. The gcc thing should be able to be worked around to make a leaner install, but I wanted unison for use before the maemo summit. Kind of handy to sync stuff over and know you can edit it with the device. Of course you could always rsync from the device when you get home again, but unison is just a nicer bidirectional solution.

Oh by the way, which one's pink?

2008-07-17T05:07:00.001-07:00

This should be a really interesting conference. Right at a very exciting time for KDE, so I might be able to survive the event without an onslaught of comments on why I coded libferris instead of working on core VFS + Indexing code in KDE instead :-p~~. It will be interesting talking about nepomuk and the existing RDF+Inferencing that is in libferris. Perhaps everyone can benefit from metadata harvesting and cross communication of RDF data between KDE and libferris even if the codebases and projects are completely separate.

monkeyiq

ODF/C++ Job seeking; br; see you at LCA...

RDF, Abiword and Relations

das wiki == de filesystem

Semantic Revolutions

Copy and Paste with Semantics...

Bringing back /dev/pcm

Abiword RDF Drag and Drop

RDF Low Level Interaction in Abiword

RDF Linking in Abiword

Abiword & RDF Gusto

Calligra & RDF Smaak

RDF in ODF: Abiword & Calligra

Libferris for Fedora 15

Searching again (400ms -> 2ms)

Everything is a file? Spitting it out again...

Blocking a nostril

Change Tracking: Why?

ODF and Generic Change Tracking: part II, styles.

Libferris for Fedora 14

ODF and Generic Change Tracking

Abiword with ODT and Generic Track Changes

"The desktop" and singularity (also scanning and ferris)

From Canon CR2 Raw files to the Web

Talking: RDF and Office Documents

Libferris hits the presses again...

Foray into Qt Models with libferris

Sharing is Caring...

Pop Quiz Hot Shot - ssh

Clawmotia and QML: Moving the TV

CRUD, metadata, indexing and Trees, please

Open or Edit a QML file?

n900: The claw arrives!

Camera to Web the eagle has landed!

n900 goodies: unison, gphoto, working soprano, libferris, sixdof, coreutils, xerces3 et al

n900: The new device!

Metadata extraction and segv

Yubikeys and KDEs

Conferences...

Winning the West...

Take the Wrather With You...

Perl io::all, REST, and libferris, wagging the dog

Meritocracy, Fate Or Anarchy

redrum a distro: rm -rf /Fedora13

Libferris and flickr, vimeo, facebook etc.

Plasma, libferris, and Google Spreadsheets

Plasma & the libferris DataEngine

Desktop Annotations...

Plasma: Tree Shaped Eyes

Plasma: Environmental Awareness

Plasma: It's an abomination I tell's ya...

Looking for some coding work...

Nepomuk & Social Networking: The Golden Opportunity

Can't get *there* from here

Everything is a filesystem. Everything is an emacs buffer.

Five Star General

Libferris: now and then...

KOffice and RDF: Say it with Style...

KOffice & RDF: Who, What, When, Where?

This blog post message was filtered by the Australian Government.

Office documents that mean something?

Clawmotia, look and feel and portrait mode

Improving the CLAW!

White lightning in triplicate

I give you the CLAW!

I want my MythTV: Clawmotia

Welcome to the machine...

RDF on the device

Libferris, Soprano, Extended Attributes... the Ménage à trois

libferris 1.4.x - Nepomuk!

User overlay virtual softlinks

Race to do nothing!

geotagged image files and libferris

n810 and gphoto

Images from n810 to the Web

Them pesky web serviceses...

select...group by artist

Done bought me a new calculator...

preupgrade -- caveat emptor

7th of May: A libferris talk in Ede, Netherlands.

Can't get there from here