Hack Week

gem install owncloud-admin

2011-09-28T13:23:00.001+02:00

The owncloud admin tool is now also available as a gem. Get it with "gem install owncloud-admin". You'll need to have the rubygems package installed in order to have the gem tool available.

Ruby gems is a wonderful mechanism to distribute software. It literally only takes seconds from releasing a new version to having it available for all users. Particularly nice for prototyping, where you have frequent changes.

Side-tracked: ownCloud admin tool

2011-09-28T12:02:00.003+02:00

Klaas and Frank tricked me into getting side-tracked from my hack week project and writing a command line tool for installing ownCloud. After a little bit of hacking I have a tool, which is able to install ownCloud to a local machine or to a remote server via FTP. There are a couple of issues with setting up ownCloud, when you only have FTP access to the server, but Frank is looking into a solution to that.

The code is at github.com/openSUSE/owncloud-admin. Next steps will be adding support for other installation methods and targets, e.g. via ssh or to specific systems like some of the popular NAS systems you might have running in your basement already.

Inqlude command line client

2011-09-27T12:51:00.000+02:00

I just uploaded the latest version of the Inqlude command line client to Rubygems. This way it's easily accessible for anyone wanting to play around with it. You need the gem tool to be installed (on openSUSE it's a simple "sudo zypper in rubygems"). Then you can just do "sudo gem install inqlude" and you get the command line client, which is conveniently named "inqlude" as well.

The client is not complete yet. It does handle packages on openSUSE 11.4, so you can use it to see and install Qt libraries there. Backends for other distributions are still missing. More to do for this week...

Inqlude web site

2011-09-27T12:42:00.002+02:00

I have a prototype of the web site for the Qt library archive at inqlude.org. I just updated with the latest content. All the data there is extracted from SUSE RPMs for now. The data needs a lot more love to be more complete, accurate and helpful for application developers.

As a next step I intend to go through the library meta data, add missing info, and also add missing libraries, so that there is an initial set of useful information on the web site.

Hackweek 7

2011-09-26T14:20:00.000+02:00

It's the seventh SUSE hack week. I'm working on Inqlude, the Qt library archive, getting it beyond the prototype state. The idea is simple, create a web site listing all Qt libraries out there, and an easy way how to use them, think CPAN for Qt libraries.

There are a lot of things, which need to be done:

Finalize library meta data format
Adapt prototype tool to support the final format
Collect real meta data for as many libraries as possible
Finish the backend for installing binary packages on openSUSE via the openSUSE build service
Look into backends for other distributions, ideally using the same build service integration
Get libraries packaged, which don't have packages yet
Contribute back changes in package descriptions
Implement a Qt based client, possibly with a QML based GUI

A lot to do. Help is very much appreciated. If you are at SUSE or somewhere else, if you are a KDE, Qt hacker, a packager, an upstream library author, a Ruby programmer, or a QML specialist, don't hesitate, you are very welcome to join the fun. Just contact me, and we'll figure out the rest.

Polka

2011-08-04T14:41:00.000+02:00

Last hackweek I was so busy with coding, that I didn't blog. But for reference here is the summary of my Hackweek 6 project.

Testdrive Success

2010-06-11T20:08:00.004+02:00

After a bit of further hacking I have now access to testdrive from my SUSE Studio client. For a given build a testdrive can be started on the server and the client connects to it with an embedded VNC client. The following screenshot shows you the result, the infamous nInvaders appliance booting in testdrive.

The native VNC viewer gives great performance and is nicely integrated. This is a great environment for a little game of nInvaders.

It's Friday evening now, my hackweek ends here. I'm happy that I have reached my goal of implementing some basic functionality of a native graphical SUSE Studio client. I did a lot of infrastructure work, so that it's now much easier to add additional functionality to cover a more complete set of use cases. If somebody wants to help with implementing some more bits, I would be more than happy. But I will also try to find some time to do some more hacking on this project myself. It's a lot of fun.

Caching and more details

2010-06-11T15:24:00.003+02:00

I've now implemented caching of API requests in Studiosus, the graphical SUSE Studio client. This is essential for making the application responsive, as with cached data is can operate on native local data instead of waiting for the round-trip from the server. It's a pretty simple caching implementation based on the URLs of the requests. I would love to hear feedback about better existing caching solutions which would solve this as well or better.

So now that the client appears fast, I also improved the appliances list a bit. Garrett suggested to show the builds on the home view, so I implemented that. This gives more direct access to the builds, which are the essential object you want to work on in the client, so I think it makes a lot of sense to do it this way.

I've also worked on the Studio API itself a bit. It was lacking some API calls to handle testdrives, which I need for providing some local access to testdrives in the client. So I did a bit of Rails hacking and implemented these calls. They aren't deployed on the production system yet, though.

Source code for SUSE Studio client

2010-06-09T18:34:00.002+02:00

I have pushed the source code of my graphical SUSE Studio client to gitorious now. Get it from the Studiosus repository.

Second API call

2010-06-09T17:26:00.003+02:00

After moving kxml_compiler to QXmlStreamWriter I'm now able to do more than one API call in my SUSE Studio client. So I can now show the user information alongside the appliances list.

Now I need some caching as loading the appliances list from the server can take a while.

Hackweek V

2010-06-09T09:48:00.002+02:00

It's hackweek again. This time I'm working on a graphical client for SUSE Studio. Read more in the SUSE Studio blog. I will report more detailed progress here.

Hackweek is over

2009-07-27T17:46:00.003+02:00

Hackweek IV is over. I still have to write up my results. I got quite some things done, but there are also still a lot of loose ends. But it was a great start for the KDE SDK project. I certainly will spend some more time on it. I'll also review the design decisions I made at the beginning of the week. While working on the SDK I realized that a lot of the value such an SDK can have is not only delivered by the development tools itself, but also by integration with the community resources and the community itself. This is a powerful combination, something like developer's social desktop.

More OCS Integration

2009-07-23T18:58:00.002+02:00

I have worked a bit on the further integration of online services in the KDE SDK. Some really basic integration with Gitorious, the Build Service, and kde-apps is now implemented. There are still some missing links, like missing write support for content on kde-apps in the OCS API, but the basic idea seems to work well. Especially getting together all the information about who is taking part in the development from committers over packagers to fans opens some interesting use cases. I didn't plan this, but it seems the social desktop has great applications in the context of the KDE SDK. Let's see where this goes...

Open Collaboration Services Integration

2009-07-21T16:21:00.003+02:00

After a bit of struggling with calling KIO slaves from Qt Creator, I now have some basic integration with the Open Collaboration Services going. My friends from opendesktop are shown on the KDE Creator welcome page.

This in itself isn't really useful yet, but it's a first proof of concept for the integration of online services in the KDE SDK. Integrating access to the app listing on kde-apps.org would be one of the next steps.

The trick to use KIO slaves in Qt Creator (or any other Qt program, which doesn't use a KApplication), is to instantiate a KComponentData object. This provides all what's needed to run many of the classes which rely on some global KDE specific data being available.

Linking to KDE in Qt Creator plugins

2009-07-20T15:58:00.003+02:00

For some better integration with the KDE desktop, and to make use of some of the goodness of KDE, I would like to link to the KDE libraries in the KDE SDK plugin for Qt Creator. Apparently adding a simple

LIBS += lkdeui

to the qmake file does the trick. This is nice.

First Screenshot

2009-07-20T12:07:00.003+02:00

After a little bit of hacking I have my first screenshot now:

This is the start of the KDE SDK plugin I'm writing for Qt Creator. It doesn't do anything useful yet, but at least the basic plugin skeleton is in place.

I'm hacking in a clone of the Qt Creator sources right on gitorious.org right now. Creating the plugin wasn't really difficult, although the Qt Creator plugin interface suffers from some serious under-documentation.

Design Decisions

2009-07-20T11:59:00.002+02:00

There are millions of different ways how to create a KDE SDK. To constrain this number a bit and get some focus I took a couple of design decisions. That means I'll start with writing a KDE SDK plugin for Qt Creator which is meant to provide the main UI for the SDK.

Hackweek IV

2009-07-20T09:50:00.002+02:00

Hackweek IV is starting today. I will work on creating a KDE SDK. I will post more details later and report about the progress of the project during the week.

Hackweek IV Ideas

2009-07-14T23:31:00.002+02:00

I'm collecting some ideas for Hackweek IV.

Social Desktop is winning Hackweek III award

2009-07-02T00:08:00.000+02:00

Just to note it down, the social desktop hackweek project won the 3rd prize in the Best Overall Project category of openSUSE Hackweek III. That's a nice compliment for all the work and ideas which went into this project.

Social Desktop

2009-07-02T00:07:00.003+02:00

This is a copy of the page from ideas.opensuse.org to preserve the information in case the system goes offline.

Description

We want to integrate the data on community web sites like http://opendesktop.org (or its child sites http://kde-look.org, http://kde-apps.org, http://gtk-apps.org, http://suse-art.org) with the desktop in order to extend applications by the most unique feature free software projects have: the community. The end result could be something like a “social desktop”, where people and the interaction with the community are a central element and provide extra value to the user.

Some ideas how this could be used were presented in the Akademy keynote KDE Community websites: The past, the present and a vision for the future by Frank Karlitschek. He also presented the first version of an API how to access community web sites, the Open Collaboration Web Services API. The specification can be found on freedesktop.org.

In order to make a first step towards the goal of the Social Desktop we want to implement the Open Collaboration Services API on opendesktop.org and a desktop client library and application to access the data.

Results

Server code is active on opendesktop.org. Client code is in SVN. It includes a first version of the client API, an Akonadi resource handling person data, a GUI application to query and show person and activity data, and a Plasma data engine for the destkop.

More results and documentation of the progress can be found in Cornelius' Hackweek Blog.

People

Cornelius Schumacher works on the client library, an example UI, and the Akonadi integration
Frank Karlitschek takes case of the server side
Sebastian Trueg helps with Nepomuk integration
Dirk Mueller works on a Plasmoid to show activity data on the desktop.

Related Materials

Open Collaboration Services Home Page

Hackweek 3 Resume

2008-08-29T16:45:00.002+02:00

Hackweek is over for me now. I wrote a short summary in my regular blog.

Now with Akonadi

2008-08-29T13:39:00.004+02:00

I started to write an Akonadi resource yesterday after dinner and today I have Attica fetching the people data from the Open Collaboration Services API through Akonadi working. This screenshot demonstrates it:

And here is the proof that it actually is Akonadi, the data shown in the Akonadi console:

It was amazingly easy. Writing the resource was a breeze, because it only took kapptemplate generating a template and then following the Akonadi Resource Tutorial step by step. For accessing the data from the UI I mainly took the examples from the Akonadi API Documentation and adapted them slightly to my needs and suddenly everything magically worked. Kudos to the people writing the Akonadi code and documentation. Fantastic job.

Code landed in SVN

2008-08-28T16:12:00.002+02:00

The first code has landed in SVN. It's a small client app which operates the Open Collaboration Services API. You can get user profiles, search for users and show your activity log. Still a long way to go, but it's a nice start. The app has the working title "Attica", after the region of Greece where democracy was born.

Frank and me discussed the API in detail today and came up with a couple of changes. The backend of the app will have to be adapted once these changes are implemented on the server, but it shouldn't be a big deal. I still have to come up with some more abstraction of the REST access, though.

First Screenshot

2008-08-26T15:34:00.002+02:00

After half a day of coding I'm ready to present my first screenshot:

Community users from www.opendesktop.org live on my desktop.

Research about Social Desktop

2008-08-26T14:44:00.002+02:00

There is an interesting research paper about the Social Desktop: ContactMap: Organizing Communication in a Social Desktop. The authors investigate which social information on the desktop would help users to improve communication and other social tasks. They also come up with a prototype which looks pretty interesting.

Users in your neigbourhood

2008-08-26T14:42:00.003+02:00

Another use case from Frank's keynote: Users in your neighborhood.

Design Decisions

2008-08-26T10:08:00.003+02:00

I took some preliminary design decisions for the implementation of the Open Collaboration Services client library:

Separation of transport and content
Abstract implementation of transport using kio_http as backend and configurable URI schemes for the REST access
Job-based transport API
Concrete implementation of content classes providing a C++ native interface to the application. Maybe look into code generation for these classes.
Value based API for content. Possibly with implicit sharing.
Don't care about caching for now. Look into using Akonadi for that later.
Implement an id based relations API on top of the data objects. Maybe Nepomuk can help here.

OpenSocial

2008-08-25T12:19:00.002+02:00

OpenSocial is an API created by Google to provide a standard way to embed small apps in social web sites. It specifies a container format for embedding HTML and Javascript in a site and specifies an API how to access the site through Javascript. This way it's easily possible to write small apps which interact with the data about people and their activities which is provided by the site.

With version 0.8 OpenSocial also specifies a REST API to access container servers. This makes it much more interesting as it's not tied into specific web sites, but the data gets accessible much more widely, especially on the desktop. I still have to find a site which actually implements this API, though.

Open Collaboration Services API

2008-08-25T12:16:00.003+02:00

On freesektop.org you can find the specification for the Open Collaboration Services API. It provides a REST interface for accessing user and content data. It's already implemented on www.opendesktop.org.

Hackweek 3

2008-08-24T21:54:00.003+02:00

Next week is hackweek time again. It's the third SUSE hackweek, which means we are doing this for more than a year now. Hackweek has created lots of interesting projects and some of the results have significantly improved our distribution.

Last hackweek I was too busy with other interesting stuff, but this time I will fully participate again. The project I plan to work on is the Social Desktop. That's inspired by the keynote Frank Karlitschek gave at Akademy this year. He proposed some ideas how to get the community on the desktop, how desktop applications could be enriched by making use of the data and functionality which is available on community web sites like opendesktop.org.

One example he gave was an about dialog on steroids, which would provide more info about the people behind the applications, and would also give users a way to become a "fan" to visibly be part of the user community of an application.

Another interesting use case Frank presented was integration of online content in the help center. Lots of info about how to use application is in online forums these days and it would be great, if the user would get more direct access to this info by integrating it into the help center.

Frank has already implemented a first version of the API on opendesktop.org, so what we now need is a client implementation on the desktop. This involves questions like how to best access the REST API, how to handle authentication through OpenID, and how to make the information accessible in a useful way for applications to use it. I'm looking forwared to work on findind answers to these questions.

Hack Week Recap

2007-07-15T22:28:00.000+02:00

Hack Week ended two weeks ago, but I didn't find the time to write down some finalizing thoughts up to now. But here we go now:

Hack Week was an tremendously great experience. It was amazing how much creativity was set free. A smart move was the free breakfast for all which lead to people coming early to the offices, having a healthy meal and start hacking. It was in general a very positive atmosphere. I guess everybody enjoyed it. One frequent meme was "Do it again". Let's hope this will work out.

Two other statements I heard quite frequently were "My project turned out to be more difficult than I thought." and "I found a project which already does what I wanted to do." Both is good, because it shows that people were ambitious and the free software cosm provides a lot of solutions even to ambitious projects. Of course many developers found challenges which weren't solved before and did great work on them.

My own project was not as successfull as I would have liked. I discusses a lot of ideas and wrote some decent code, but I didn't get it to a really useful state. Garrett did some more work on the user interface which already looks quite nice and collects some useful data. We need to connect our two parts together, though, to achieve a richer experience for the user. I realized that this project has a lot of potential during the Hack Week. There are so many interesting things you can do with it (provided it works at some time) and when talking to others about the project, many exciting ideas came up. So I'm looking forward to spend some more time on this project.

Make it colorful

2007-06-29T17:10:00.001+02:00

I have removed some of the ugliness of the collector code. It now more or less correctly parses OPML files now which define the services which are to be aggregated and writes it in a way the Rails GUI can understand.

When Klaas saw the GUI he said: "Make it colorful!". So I did:

This clearly is a cry for help by an artist as you can see (if you didn't get blind by looking at the screenshot).

Collaboration Magic

2007-06-28T20:02:00.000+02:00

At hackweek two cases of serious collaboration magic happened to me.

At the beginning of the week I talked to Garrett about what he was planning to do. He told me and we quickly realized that it was the same idea from two different angles. We were both thinking about a dynamic SUSE portal. My idea was focused more on the backend side and how this could be useful internally. Garret was coming from the UI side and how this could be useful to the external community. A perfect match :-)

The other case of collaboration magic happened when Tom realized that he was stuck in his project because of some kernel problems he wasn't able to fix. So he made a short detour and implemented an Atom feed for SWAMP, ready to be used by my project. Jippie!

Second Screenshot

2007-06-27T15:17:00.000+02:00

Breaking News: Here it is, the second screenshot. You have to look closely to see the difference to the first screenshot. In the Hack Week Blog part there now is an additional entry: First Screenshot. That's the first sign of my code doing the right thing. Huzzah!

Ok, now on to the third screenshot... (just kidding).

First Screenshot

2007-06-27T15:03:00.001+02:00

After a day of happy Rails hacking I now have my first screenshot:

It already looks vaguely similar to the initial mockup. Under the hood there is a set of small Ruby modules which collect data from various sources and provide them as Atom feeds to the GUI. The GUI is a small Rails app which shows the feeds. The structure of the page on the screen is defined by an OPML file. The code still lacks in terms of nearly everything, but at least it's a first working slice through the application.

Codename: Molecule

2007-06-27T12:01:00.000+02:00

I had to came up with a codename for my project, so I could properly name my git repository and the rails directory. So what could be a better name for an aggregation of Atom feeds than "Molecule"?

Design Document and Mockup

2007-06-25T14:46:00.000+02:00

There is progress on my Hack Week Project Dynamic Web Service Portal. I have created a fantastic design document and a mockup.

In the mockup you can see the aggregation of data from different sources. I intend to use Atom feeds for that which are created by small modules accessing the sources via a web service. In the simplest case this is already an Atom feed where nothing has to be done other than fetching it. In less simple cases there is a bit of parsing and reformatting involved or operating a SOAP protocol or similar things.

What you also can see in the mockup (well at least if you are so lucky to decifer my handwriting) are the actions associated with some entries. For example for resolving a bug, showing the diff associated with a SVN commit, marking a mail from a mailing list as todo or for closing a bug resolved by a SVN commit containing the corresponding bug number in the commit message. These actions I intend to embed in the Atom feeds using some custiom extensions. The result would be something like "Activated Atom".

Now add a bit of code to actually create the user interface and we are done. Sounds easy, doesn't it? Let's see. Back to coding.

Start of Hack Week

2007-06-25T12:40:00.000+02:00

Hack Week has started. It's exciting. The complete Linux engineering team at Novell is working on whatever they find interest. We will have one week without the normal obligations by the job, but with time for working on crazy ideas. See the openSUSE Idea Pool for details about what's going on and some interesting video footage.

I will work on a Dynamic Web Service Portal. More info and first code is under production...