Libferris has been gaining some KDE love in recent times. There is now a KIO slave to allow you to see libferris from KDE, also the ability to get at libferris from plasma.

I've been meaning to update the mounting of some Web services like vimeo for quite some time. I'd also like to expand to allow mounting google+ as a filesystem and add other new Web services.

In order to manage time so that this can happen quicker, I thought I'd try the waters with a pledgie. I've left this open ended rather than sticking an exact "bounty" on things. I had the idea of trying a pledgie with my recent investigation into the libferris indexing plugins on a small form factor ARM machine. I'd like to be able to spend more time on libferris, and also pay the rent while doing that, so I thought I'd throw the idea out into the public.

If you've enjoyed the old tricks of mounting XML, Berkeley DB, SQLite, PostgreSQL and other relational databases, flickr, google docs, identica, and others and want to see more then please support the pledgie to speed up continued development. Enjoy libferris!

Turns out I haven't posted here for two months, so here we go again: Billboard, your favorite low-power mode standby screen will soon receive a new update - version 1.0.9 has been uploaded to Nokia Store QA two days ago, and should hopefully pass QA and be available as an update in the next few days. This release brings a few major under-the-hood improvements and small bugfixes:

• Fixed MeeCast icon (in 1.0.8, you can already use <<{meecast-icon-src}>>)
• New formatter that allows you to nest {} expressions used for adding dynamic content
• Optional image dithering (using # after the filename) for better colors in low power mode

With the new formatter, you can now output {} expressions in your scripts so that they get replaced, and similarly pass {} expressions as parameters to your scripts (for example to modify them in some way before displaying). This should allow for even more customization, some examples of what users have been doing on their N9 standby screen can be seen in the Billboard Standby Screen support thread on talk.maemo.org.

If you are looking for additional ways to tweak and enhance your Billboard-on-N9 experience, have a look at billboard-scripts, a growing collection of Shell and Python scripts that provide even more ways of customizing your standby screen.

If you haven't purchased Billboard from Nokia Store yet, you can get the current version now for your N9, and get the upgrade to 1.0.9 as soon as it's available. If you are already a happy user, watch your application updates in the next few days, and get the new version.

In this blog series, I am presenting a solution that I've developed that enables the use of Wayland on top of Android hardware adaptations, specifically the GPU drivers, but without actually requiring the OS to be Bionic based.

Next up in my list of things I did in the last weeks/months and never blogged about is Petals (Nokia Store link), a "beautiful, brain-teasing puzzle game for 1-4 players" if the game's website is to be believed (I would like to think it is...). As always, there's some technical details about the porting and creation of this game. While another recent game (Tetrepetete) has been done on a low level (C++ using no frameworks, and interfacing with multiple front-ends directly, including an OpenGL ES frontend, a console-based ncurses frontend(!) as well as a server-sent events/XHR/Canvas2D-based HTML5 frontend(!!)), this one is approaching things from a very high level: JavaScript.

Petals: A puzzle game written in pure JavaScript and QML The gameplay logic of the game is implemented in pure JavaScript (without any QML dependencies), so it could easily be ported to, say, HTML5, but for integration reasons, QML seemed like the better choice for a release on the N9/Harmattan. Also, writing things in JavaScript wouldn't preclude a console-based frontend using nodejs and node-ncurses from happening should the need arise (making the flowers look good in ASCII art would be the challenge there - or cheating by using libcaca). Ok, ok - stop cursing, I'll stop talking about curses (cue laugh track).

Writing pure QML applications has the advantage of easing porting to Qt 5. While QtQuick 1.1 still exists on Qt 5 (and is the only QML option at the moment if you are also targetting iOS), QtQuick 2.0 is usually the better choice for performance reasons.

In my case, the changes necessary to port from QtQuick 1.1 to QtQuick 2.0 were:

• Change "import QtQuick 1.1" to "import QtQuick 2.0" (sed(1) helps here)
• Instead of assigning a JavaScript function to a property to create a dynamic property binding (item.someprop = function() { return otheritem.otherprop * 3.0; }), this function has to be wrapped in a call to Qt.binding() in Qt 5 (see "Creating Property Bindings from JavaScript" in the Qt 5 docs)
• Instead of using SQL Local Storage directly as in QtQuick 1.1, use QtQuick.LocalStorage 2.0, which you can still do in your .js files - use ".import" as described in this blog post
• In your C++ launcher (in case you need one), QApplication becomes QGuiApplication, and QDeclarativeView becomes QQuickView
• Use "QT += quick qml" instead of "QT += declarative" in your qmake project file

And that's basically it. Of course, as this is a full-screen game with custom UI, no platform-specific components (such as Harmattan Components or Sailfish Silica) are used, so porting is a bit easier there (no need to "wait" for specific components to be compatible with QtQuick 2.0, which might realistically not happen at all for Harmattan Components). More screenshots of Petals and download links for multiple platforms can be found on the Petals Website.

I’m thrilled to announce that my paper “Block Coordinate Descent Algorithms for Large-scale Sparse Multiclass Classification” (published in the Machine Learning journal) is now online: PDF, BibTeX [*].

Abstract

Over the past decade, l1 regularization has emerged as a powerful way to learn classifiers with implicit feature selection. More recently, mixed-norm (e.g., l1/l2) regularization has been utilized as a way to select entire groups of features. In this paper, we propose a novel direct multiclass formulation specifically designed for large-scale and high-dimensional problems such as document classification. Based on a multiclass extension of the squared hinge loss, our formulation employs l1/l2 regularization so as to force weights corresponding to the same features to be zero across all classes, resulting in compact and fast-to-evaluate multiclass models. For optimization, we employ two globally-convergent variants of block coordinate descent, one with line search (Tseng and Yun, 2009) and the other without (Richtárik and Takáč, 2012). We present the two variants in a unified manner and develop the core components needed to efficiently solve our formulation. The end result is a couple of block coordinate descent algorithms specifically tailored to our multiclass formulation. Experimentally, we show that block coordinate descent performs favorably to other solvers such as FOBOS, FISTA and SpaRSA. Furthermore, we show that our formulation obtains very compact multiclass models and outperforms l1/l2- regularized multiclass logistic regression in terms of training speed, while achieving comparable test accuracy.

Code

The code of the proposed multiclass method is available in my Python/Cython machine learning library, lightning. Below is an example of how to use it on the News20 dataset.

from sklearn.datasets import fetch_20newsgroups_vectorized
from lightning.primal_cd import CDClassifier
 
bunch = fetch_20newsgroups_vectorized(subset="all")
X = bunch.data
y = bunch.target
 
clf = CDClassifier(penalty="l1/l2",
                   loss="squared_hinge",
                   multiclass=True,
                   max_iter=20,
                   alpha=1e-4,
                   C=1.0 / X.shape[0],
                   tol=1e-3)
clf.fit(X, y)
# accuracy
print clf.score(X, y) 
# percentage of selected features
print clf.n_nonzero(percentage=True)

To use the variant without line search (as presented in the paper), add the max_steps=0 option to CDClassifier.

Data

I also released the Amazon7 dataset used in the paper. It contains 1,362,109 reviews of Amazon products. Each review may belong to one of 7 categories (apparel, book, dvd, electronics, kitchen & housewares, music, video) and is represented as a 262,144-dimensional vector. It is, to my knowledge, one of the largest publically available multiclass classification dataset.

[*] The final publication is available here.

After the QUItIndicator trilogy which introduced idea, design and performance of a specific Qt5 QML component there's room for more, right?! Something like this:


This time we have a dynamic QML component for showing the remaining power of your mobile device battery. As a recap, with "Dynamic QML component" I mean someting which utilizes not only basic QML animation properties (position, opacity, scale etc.) but also new Qt5 features (shaders, particles, scenegraph powa!) to appear "more dynamic". Maybe it's just me, but I would love to see UIs really utilizing modern GPUs... and accelerating this progress is one of the reasons why I code these examples and blog about them. Another reason being to rule-the-world, obviously ;-P

Instead of explaining design & features of QUItBattery component I'll let this video to do that:





If you want to use this liquid battery component in your UI: Download the sources from here, copy QUItBatteryComponent directory, import it in your QML and off you go. Happy hacking!

The Tizen Developer Conference is coming up from the 22nd of May until the 24th of may 2013 - It is in Downtown San Francisco (https://www.tizen.org/)I will be there the whole 3 days but I might be hard to grab as I will be running around. If you want to touch base - just contact me through linked in, email or twitter (https://twitter.com/yapellet).
If you are going there, go and check out the following talks from my lab (SRA's Advanced Software Platform). One is "Accelerated HTML5 Rendering for the Tizen Platform" by Henry Song. The other is "WebKit for Tizen" by Laszlo Gombos. Both of those talks are on the WebKit track. Though they are litteraly the top of the iceberg when it comes to our activity, it gives you an idea of what some our interests are.

There is also a presentation around a service prototyping for social appointment entitled Rendez-vous  under the Tizen Collaboration Projects. This is presented by Stanford students. It is a small project that we kick-started and sponsored last February as part of the CS210 Stanford Class.
On side note:  Art Dahm is giving a talk about building Tizen apps using Enyo & Phonegap. Art - now working for LG - used to be part of my team working  when I was working on webOS at HP. I will be sure to check this one out to see if I can meet some of the old team :)

See you there.

Get out your Buzzword Bingo cards, we're talking HTML5. And Canvas2D. And WebGL. See? Check them off and then continue reading. So, while writing "native" apps using JavaScript is definitely possible and works great with QML, some games are just simple enough (or want to have a broad enough audience) to warrant writing everything in HTML5.

The logical step after the "Volume+ as Camera Button" app (Nokia Store link) for the N9 is another app that allows you to take photos while not touching your N9 at all. While time-triggered photos are fun, remote-triggered photos are.. erm.. "funner"? So what kind of remote "buttons" can we easily get on the N9? The remote control button on the headset is both "remote" and a "button". Also, as seen in Panucci and gPodder versions since the N900, Bluetooth headset buttons can also be queried by applications. So what do we get by combining remote control and photo taking? The Headset Camera app (Nokia Store link) for the N9! Or - for the visual reader - this:



If you want to integrate such features into your own app, the code for querying the headset buttons is readily available in the gPodder source tree (src/gpodder/qmlui/helper.py):

import dbus

class MediaButtonsHandler(QtCore.QObject):
    def __init__(self):
        QtCore.QObject.__init__(self)
        headset_path = '/org/freedesktop/Hal/devices/computer_logicaldev_input_0'
        headset_path2 = '/org/freedesktop/Hal/devices/computer_logicaldev_input'

        system_bus = dbus.SystemBus()
        system_bus.add_signal_receiver(self.handle_button, 'Condition',
                'org.freedesktop.Hal.Device', None, headset_path)
        system_bus.add_signal_receiver(self.handle_button, 'Condition',
                'org.freedesktop.Hal.Device', None, headset_path2)
 
    def handle_button(self, signal, button):
        if signal == 'ButtonPressed':
            if button in ('play-cd', 'phone'):
                self.playPressed.emit()
            elif button == 'pause-cd':
                self.pausePressed.emit()
            elif button == 'previous-song':
                self.previousPressed.emit()
            elif button == 'next-song':
                self.nextPressed.emit()

    playPressed = QtCore.Signal()
    pausePressed = QtCore.Signal()
    previousPressed = QtCore.Signal()
    nextPressed = QtCore.Signal()

MediaButtonsHandler is already a QObject subclass, so you can easily expose an instance of this class to your QDeclarativeView rootContext() and connect to the signals in QML (such a "headset button handler" might actually be a good candidate for inclusion into nemo-qml-plugins in Sailfish OS and Nemo Mobile?). As it's really just using the Python D-Bus bindings to get property changes from Hal devices, the code above should be easy (read: trivial) to port from Python to Qt/C++. Be aware that you need to connect to both .../computer_logicaldev_input_0 and .../computer_logicaldev_input, which can both exist if you have a cable headset and a Bluetooth headset connected at the same time.

You can get the Headset Camera App for the N9 in Nokia Store now, there is also a video on YouTube showing the app. Or start integrating headset button features into your own app or scripts by adapting the code above. One use case that comes to mind is using the previous/next buttons on a Bluetooth headset to control a photo slideshow on the N9 connected to TV-Out. Enjoy :)

I would like to share with you this port of SeriesFinale for Blackberry.

Unlike the other versions, I was not involved in the development of this one. It was developed by Micke Prag, who also started the Meego/N9 port back in the day.
I developed the first version of SeriesFinale in 2009 for the defunct Maemo system and released also a version for the N9/Meego in 2011 (there was also a version for GNOME but I never finished it…). It is very good to see that it continues its life even if I am not involved this time.

I don’t own a BlackBerry so I am not able to try it but judging from this video, it definitely looks good so if you’re a BB user, check it out!

Judging from the success that a clone for Android and a similar online service have, it seems like I could have started a whole business out of it…

I am looking for Javascript software engineers. You need to have expertise in Javascript, HTML5, CSS,  and high-level programming concepts. Developing experience on  Webkit or Firefox engine as well as a strong understanding of browser rendering is obviously a plus.  You need to be knowledgeable on the common JavaScript Libraries (jQuery, Sencha, Enyo,etc...). This would essentially be to build a team to work on web UX technologies and interfaces.
On a similar subject, I am also looking to expand our research activity around Javascript itself and Javascript tools (first result to come soon). So if you have deeper knowledgeable about the language itself or the frameworks, do not hesitate to contact me as well or meet me at the Tizen developer conference.

Back in the day Intel had Moblin (PC and tablet OS), and Nokia had Maemo. Both of which came together to form MeeGo, an effort which has since been abandoned. Instead we have Tizen, a OS targeted at not just mobile phones, but also in vehicle systems, tablets and the PCs. While we’ve seen it running on mobile phone hardware (ARM chips), there has so far been nothing on the PC front, that was until today.

At the Tizen Conference 2013, I got a look at Tizen running on Intel’s Ivy Bridge ultrabook. While the PC release of Tizen is still some time away, the following video should give you a good idea of what to expect in terms of the UI and functionality.

The free to download Tizen images for laptops will be made available through Tizen.org website. While the best platform to run that release would be Ivy Bridge and up, I’m told that work is being done to support older chips and netbooks (in a limited way) as well.

(YouTube link)

Thanks to Patrick from Intel for the demo.

We’ve seen Open Mobile’s implementation of brining Android apps to Tizen before, but that method involves deployment on a platform level. The Open Mobile code needs to be a part of the Tizen code before the Android apps can be run on Tizen. Infraware, the company behind the Polaris App Player has a different approach.

The way this works in that they have a solution called PAG (Polaris App Generator) that lets the developer upload an Android app (APK) and it converts it into a TPK file that can be installed on the Tizen device. Then to run this modified TPK, you need to have the PAP (Polaris App Player) installed on the phone. Once that’s present, the modified TPK that you just installed will launch inside the PAP, and behave like a native Tizen app.

The company is giving away the Polaris App Player to users for free, in the hope that developers will use their service to deploy their Android apps to Tizen, thus making them money. While I have my doubts about Android Apps ‘officially’ being supported on Tizen, Infraware has a chance of succeeding as they don’t need to be a part of the platform, and have a business model as long as the developers and users are on board. Here is a video of the implementation in action:

While there is a noticeable slow down while running high performance games, most apps should run fine. Although, there will always be the issue of not all UI elements working properly because the app was originally made for Android in mind. The current implementation is based on Android 2.3 Gingerbread, so that means none of the ICS and up only apps, will be available. According to the company, PAG can port 80~90% of Android apps to Tizen app without re-compiling. Some examples include games such as Angrybird series, Counter Terrorist, Treasure Detective, Fruit Slice, Drag Racing, Shut Bubble Deluxe, Cut the Rope Free, Air Hockey etc.

Going into the Tizen Developer Conference there were a few major questions that people wanted answers to. The developers wanted to know details about the Tizen App Store, everyone wanted to know when we’d see the first Tizen devices, which would be the carriers supporting them, and what about the big games apps?

The keynote did manage to answer a few of those questions, albeit in not complete detail. Tizen devices are coming this year, but Jong-Deok Choi, EVP, Samsung won’t be more specific. In terms of operator support, Roy Sugimura from NTT DOCOMO has stated that they will be carrying the first Tizen device in the second half of this year. Frederic Dufal, Devices Technical Director for Orange has also announced that they are committed to launching a Tizen project this year (end of summer, Europe only).

• The big change from Tizen 1.0 to the current 2.1 release is the ability to run native apps. Samsung has folded Bada into the platform, although this was not specifically mentioned in the keynote.

• The Tizen Store has been announced, and is open for app developers to submit their apps. Users cannot access it yet.

• Tizen 2 also has an inbuilt security layer, McAfee has contributed to this. 

• A Tizen App Challenge has been announced. Submissions will be accepted June 1 onwards, and a total of 4$ Million is up for grabs. 

• Also big news for gaming enthusiasts, some of the top gaming engines like Unity, Havok, Game Salad are coming to Tizen. 

• NTT DOCOMO will make a Tizen device available in the second half of the year.

• So will Orange. They like Tizen because of its open nature, and HTML5 focus. The launch will be a part of the ‘back to school’ campaign that will start at the end of summer. Europe only for now.

• We also got a look at the in vehicle application of Tizen, Jaguar | Land Rover wants to push the boundaries of what people expect from a in-car Linux based system. A competition to generate ideas, UI elements and functionality is also under way. 

• Finally, the next major release of Tizen will be the big 3.0. Expect this release in 2014 devices. The roadmap for the release isn’t complete yet, and the development will be done openly on Tizen.org. They encourage platform developers and other open source developers to contribute. 

•  There is a tremendous amount of push to bring big name developers to Tizen. Facebook, Angry Birds were named in the keynote. I saw demoes of Gameloft’s Asphalt 7 and Real Golf running on a Tizen reference device, along with games based on the Unity engine, games from Sega, and Opera Mini.

The Tizen App Store was officially announced today at the Tizen Developer Conference, and it will be the goto place for all your application needs. The store isn’t accessible to the general public yet, but is open for developers to submit their apps (seller.tizenstore.com). Registration and publishing apps is free, and the promise to developers is that their apps will be validated within 3 days of being submitted for approval.

The Tizen Store is pretty much everything you expect from a modern App Store, however it does have a couple of novel features. One of them is the ‘Discounted’ section. So if any app is on sale, it will automatically show up there. The performance seemed smooth, and the UI kind of reminds of the Nokia Store on the N9, and parts of Google Play.

Here is a detailed look at the Tizen App Store running on a a Tizen phone: