The Blog of Cornelius

Don't sell free software cheap

2013-05-20T13:11:00.000+02:00

How can I get paid for free software development? That's a question many developers ask. And it's a good question, because software development is expensive, no matter what the license is. Money is one way to pay for this, but fortunately there are many other ways to get paid for free software. The one thing you should never do, though, is to sell free software cheap.

It's tempting. Put some ads on your blog, a donation button on the project page, get a low paid student job, etc. It's fine, if you can work on free software, right? Some money is better than nothing, isn't it?

No, it isn't. Because it interferes with other ways of being compensated for free software development, such as reputation, control, freedom, learning, or just satisfying your curiosity. Money adds dynamics which can go against these. It changes to whom you are accountable, it alters expectations, and it can actually harm your motivation, because money is a bad motivator. So you need to be very careful when putting money into the equation.

That doesn't mean that there are no good ways to get paid money for free software development. In fact an increasing number of companies have realized that they are better off developing a good part of their software as free software, and they don't compromise on quality or payment. So there are well-paid jobs for free software developers. Guess who gets these jobs. Not those who do it for cheap, but those who have built up a good reputation as a free software developer.

Contributing to free software actually is a great way to build up a career. You are in control. You don't need a university or company program, you can start any time. You can build a reputation doing something you want, something that matters. You can learn and grow following your passion. This is a great foundation for a professional career, and studies show that committers to free software actually get higher salaries than those who don't do this.

Your work on free software is an investment in your happiness, your career, and a better world. Don't sell it cheap.

How to deploy a Rails app to Heroku on openSUSE 12.3

2013-04-21T00:30:00.000+02:00

One of the most easy ways to deploy a Rails application for use by others is Heroku. They provide Rails on their platform as a service. Their most basic plan is free, but it usually is enough for development and use for testing. You can then scale up to production use by paying for additional services and capacity. You just push your code, and Heroku takes care of running all the services needed to actually serve the application.

They have an excellent guide about Getting Started with Rails 3.x on Heroku. If you follow these steps you'll quickly have your app running in the cloud. There are a few things which are specific to when you do it on openSUSE 12.3. Here is a quick summary.

Heroku uses PostgreSQL as database backend. To minimize problems caused by divergencies in environments it's a good idea to also use PostgreSQL on your local development system. I wrote a separate guide How to run Rails with PostgreSQL on openSUSE 12.3, which explains how to do that on openSUSE 12.3.

Heroku provides a client, which you can use to manage your apps. For openSUSE 12.3 you'll need the standalone version. Install it following the instructions. To make it accessible on the command line just as "heroku", create a symlink to your local bin directory:

sudo ln -s /usr/local/heroku/bin/heroku ~/bin/heroku

heroku login

and follow the instructions from the Heroku guide.

If you already have the app created on Heroku, you can connect your local git checkout to it by doing

git remote add heroku git@heroku.com:APPNAME.git

Replace APPNAME by the name of your application on Heroku.

You can then deploy by

git push heroku master

If you follow the recommendation of the Heroku guide to use Unicorn as web server and Foreman to run it locally, you need to make bundler available under the "bundle" command, otherwise Foreman will not start:

sudo ln -s /usr/bin/bundle1.9 /usr/bin/bundle

Then you can start your application locally with

foreman1.9 start

and you can access it at localhost:5000.

That's it. Have fun deploying your Rails application to Heroku on openSUSE.

How to run Rails with PostgreSQL on openSUSE 12.3

2013-04-19T15:36:00.000+02:00

Ruby on Rails uses SQLite as backend database by default. Using PostgreSQL instead is not difficult, but it needs a little bit of setup and configuration to get the database up and running and connect the Rails app to it. What you need to do slightly varies with the platform you are on. Here is how you do it for a development environment on openSUSE 12.3. Running it as a production database is a different story and needs quite some more considerations to address questions of performance, scalability, backup, availability, etc. But for a development environment using PostgreSQL with Rails is quite simple.

First of all you need to install PostgreSQL:

sudo zypper install postgresql92-server postgresql92-devel

This installs the latest available version. The devel package is needed to build the Rails drivers.

Then start the database server:

sudo /usr/sbin/rcpostgresql start

If you want to automatically start the server on boot enable the service with:

sudo chkconfig -a postgresql

To finalize the setup of the database server you need to create a user, which Rails uses to access the database. You can choose whatever username you like, but the setup is most simple, if you use the username of the user under which you do your Rails development. The -d option allows the user to create databases, so the corresponding rake tasks can do their job.

sudo sudo -u postgres createuser -d USERNAME

You can check the results and later the content of the database directly in PostgreSQL by using the PostgreSQL console. You can start it with the following command. As with the createuser command, via sudo you impersonate the postgre user as root, and then are allowed to connect locally to the database server.

sudo sudo -u postgres psql

By querying the users table you can check the existing users and their rights on the PostgreSQL console:

SELECT * FROM pg_user;

To make Rails talk to PostgreSQL instead of the default SQLite backend, you just need to exchange the database driver by adding the pg gem to the Gemfile and removing the sqlite3 gem. Then run bundler to install the gems:

bundle19 install

To connect Rails to the database, you need to create the database configuration in Rails. Create a file config/database.yml with something like the following content. You need to replace USERNAME by the name of the database user you create in one of the previous steps, and APPNAME by the name of the Rails application. You are free to use whatever name you want there, but usually using something like the appname makes it easier to keep an overview.

development:

adapter: postgresql

database: APPNAME_development

username: USERNAME

test:

adapter: postgresql

database: APPNAME_test

username: USERNAME

production:

adapter: postgresql

database: APPNAME_production

username: USERNAME

Then finally you need to create the databases with:

rake db:create

and create the database tables by running the migrations of your Rails app:

rake db:migrate

That's all. Now your Rails app runs on PostgreSQL, and you can do all your development and testing as usual.

Human-Computer Interaction Class

2012-12-19T01:40:00.000+01:00

Sometimes you might think that creating good user interfaces needs magic, which can only be done by MacBook-carrying designers, who wear fancy glasses, and can see ultra-violet colors. Let me reveal you a secret: It's not like this. Good user interface design is just a part of a proper engineering process, which can be done by everybody willing to take this seriously. In his HCI class Scott Klemmer tells us how.

I joined the class in spring this year out of curiosity and interest in the topic. How would an online class about human-computer interaction design deliver?

The class consisted of a series of video lectures accompanied by some quizzes, and a practical project, which was done in a number of assignments. These assignments built up on each other and went through all the steps of designing a user interface. For every assignment there was a peer-assessment step, where you got to see and evaluate what others had done, and you received feedback on your own work. This was the most experimental part, but arguably the most interesting one.

The assignments covered what is needed to create a good user interface, it started with need finding and some quick prototyping, continued with building and refining a functional prototype for user testing, and concluded with actually performing and evaluating the user testing. There was a huge focus on iterating quickly and gathering quality feedback as data for further iterations. So it really was more about observing and drawing conclusions from these observations than about magic creativity and beautiful artwork. It's something which everybody can do with a little bit of practice and awareness of what it is about.

The project I ended up doing was a personal travel assistant web site. I called it "I will travel...". I started with watching some people packing stuff for travelling and after going through some quick prototyping and feedback gathering I built a small web app to help with remembering and checking what to pack. I have documented the process as my story of Stanford's HCI class 2012. There you can find the material I created, and how I went through the different steps of the design process. I hope that this can be useful to some of you, who are interested in an example how to deal with human-computer interaction design. The prototype is running on Heroku as "I will travel...".

The course was an interesting experience. The lectures were great. They covered a good combination of overview and selected in-depth material, and they had a number of really insightful examples. I liked the one most, how to turn an abstract hard-to-understand number adding game into an intuitively playable graphical game by using some magic square (yes, this was the one occasion were actual magic was involved). We are talking about Tic-Tac-Toe here. The lectures also included a nice collection of book recommendations for further reading. I already knew some of these, and they are great.

The ongoing project was fun and creating a lot of insight. From doing something yourself you learn so much more than from just reading or watching. The peer-assessment going with the projects was sometimes useful and enriching, sometimes horrible. It took much more time than I and many others expected, because you had to go through a training and had to evaluate at least five other assignments before you could get ratings for your own. Many people dropped out because of that, and in quite some cases the feedback was only the bare minimum the course app allowed to give. That could be disappointing. But it was great to see and review so much of what others did. Lots of good (and also some bad) stuff out there.

You could definitely tell that this was the first time the course was done this way. There were a number of glitches and it would have been great if the course staff would have been a bit more active and responsive. But in the end it worked out fine, and I'm sure they learned from all of this, and later classes will address some of the issues. From some thousand students who started the course a bit less than 800 completed the full class.

If you are interested in what's behind human-computer interaction and you want to get some practice in a setting, which provides motivation and feedback, and is targeted at quick results, I can only recommend you to take the HCI class as well.

Fifteen years of KDE e.V.

2012-11-30T16:23:00.000+01:00

This text I wrote as introduction to the latest quarterly report of KDE e.V. I reproduce it here for those of you who haven't read the quarterly report yet (which you of course still should do ;-).

These days we are celebrating a special anniversary. It's the fifteenth anniversary of KDE e.V., the organization behind the KDE Community.

On November 26th 1997, Matthias Ettrich, Kalle Dalheimer and Martin Konold got together at Matthias's student flat to found an association according to German law. Thisorganization would represent and support the community of the small but growing software project they had started a year earlier. They dragged in their roommates and girlfriends to reach the minimum number of seven founding members. After some speeches they formally decided the first articles of association of KDE e.V. Further details about what happened at this historical event got lost over time, but rumors say that it involved discussions about C++ and packet radio.

From today's perspective, it's remarkable the foresight and vision the founders of KDE e.V. demonstrated by putting a formal organization behind the young open source project KDE. This certainly wasn't an easy step, but it proved to be a pivotal element in growing and sustaining the community over one and a half decades. The agreement with the owners of Qt to ensure the freedom of the toolkit, running ten global KDE conferences, organizing many dozens of developer sprints, owning the trademark, maintaining an office and an employee to support the community, all this wouldn't have been possible without KDE e.V.

Just recently we saw a demonstration of what's possible in the KDE community with the Randa meeting, a combination of sprints taking place in the solitude of the Swiss mountains. Mario Fux, the restless organizer of these meetings, brought together people from the accessibility, education, multimedia, and workspace communities to work on their projects for a week of concentrated collaboration. To make this possible, KDE e.V. ran a donation campaign; the result went beyond our wildest dreams. Our friends and supporters donated more than €10,000 to support volunteer contributors to attend this event and spend valuable face-to-face time working together on free software. You can read more about the meeting in this quarterly report. I'm humbled to be part of a community that makes something like this possible. Thank you so much.

Finally I want to applaud another achievement of the community, the creation of the KDE Manifesto. As the result of a process over a number of years to understand the core of the community and what defines our identity as KDE, the KDE Manifesto has been written and is published at manifesto.kde.org. For those who are familiar with KDE, there are no surprises, but it is a concrete community artifact that defines who we are, and makes it explicit to us and everybody else. It's a reminder and guideline for KDE and also for the work we do in KDE e.V.

On this fifteenth anniversary, we look back with pride, celebrating one of the largest and longest-lived communities in the Free Software world, and look forward to the future with curiousity and confidence.

On the next fifteen years of KDE and KDE e.V.!

ownCloud 4.5 in a box

2012-10-11T20:34:00.000+02:00

The ownCloud community released ownCloud 4.5 today. It's a big release coming with quite some new features. On the heels of the ownCloud release I updated my ownCloud in a box appliance, which provides a very simple way to try ownCloud on a multitude of different platforms. It comes on a shiny new openSUSE 12.2 and also adds the new KVM format, which runs happily on native KVM as well as on an OpenStack cloud like SUSE Cloud.

Give it a try. It's easy.

For those who are late to the party, here is what ownCloud and ownCloud in a box are:

ownCloud is an open source file sharing service, which gives you control about your data. It's easy to install and run on the servers or services you choose. So you have access to your data on your own terms. It's your ownCloud.

ownCloud in a box is a fully pre-configured software appliance, which you can run on whatever system you want, physical servers, virtual servers, or in the cloud. It's based on openSUSE and built with SUSE Studio. But as a user you don't have to care. Everything comes ready to be used as your ownCloud in a box.

It's great to see the ownCloud community thrive and push out release after release. Keep going!

Hack week: node.js, business model hacking, and more

2012-09-17T09:42:00.000+02:00

A couple of weeks ago we had hack week 8 at SUSE. As usual the company took a break for a week and put some focused time of uninterrupted hacking on a broad range of ambitious, creative, hard, innovative, fun, and whatnot projects.

I started with an unusual project and did some business model hacking during the first part of the week. Together with a couple of other people we sat down and used the framework of the business model canvas to discuss the SUSE business model. It's an interesting exercise. I'm used to think from a technical point of view, and the canvas fits this way of thinking pretty well. It visualizes the key components of the business model like the value proposition, customer segments, key activities and resources as well as costs and revenue streams, and makes it easy to connect these. Based on this model it's pretty natural to see what variations of parameters and components of the model mean, and it's interesting to discuss how business models can be developed and changed overt time.

The second part of the week I spent on getting some experience with node.js. I chose a collaborative card board for virtual sticky notes as an example application and implemented a first working prototype of that. It quickly evolved into a combination of a bunch of technology, using HTML, CSS, jQuery, Redis, and socket.io, next to node.js. The code is in the sticky repository on Github, and a live instance is running on the Windows Azure cloud at sticky.azurewebsites.net.

Playing around with node.js was interesting. The totally asynchronous programming model makes sense. It's done with attitude, I like that very much. It also creates a number of practical problems, though. Synchronizing events can result in pretty ugly code. So this needs some additional tooling and helpers, where apparently no standard way of doing things has emerged yet. But this probably is only a matter of time.

One of the standard arguments for node.js is that you can use Javascript as the same language on the client and the server. I'm not sure I buy into that. It's two very different domains, and the code deals with very different objects. Manipulating the DOM is not the same as writing to a database, and the frameworks you use for that, like jQuery, dominate the code. It's certainly nice to be able to use the same language, but this wouldn't be a reason for me to switch.

When I did the first version of my prototype application I used standard AJAX calls for implementing the interactive parts. But this creates quite some overhead. Especially if the application is not focused on content, but much more on interactive elements, this becomes less and less practical. So I looked for alternatives, and settled on socket.io as a library, which abstracts direct two-way communication between client and server in a very nice model, using web sockets or whatever else is available. This made the code quite clear, and the interaction fast and simple. It also worked without any problems out of the box. Pretty impressive.

Finally I was looking for node.js hosting. There are a number of options out there. I had a close look at Nodejitsu. They have a very impressive command line client. I think it's the best one I have seen so far for operating a cloud service. But I ran into a few technical issues, and wasn't able to quickly get the app up and running. They are in beta, so I don't blame them for that. The solution I settled on was Microsoft's Windows Azure. It's a bit of a surprise, but they offer a great cloud platform, which can easily be used from Linux. Their web pages support node.js out of the box. You deploy the code by pushing to a git repository the service creates for you, and that's it. Their web console is very slick and it's fun to manage and monitor your applications there.

That's what I did at hack week 8, but I realize that I haven't reported what I did at hack week 7. So here is a brief recap.

I started with working on Inqlude, the Qt library archive. It's in a state, where it's sort of usable, but the information needs to be updated and completed. I got side-tracked during hack week and haven't found much time to work on it since then. That's something to pick up later. Especially around the release of Qt 5 and KDE frameworks 5, it would be great to have the library archive in a good shape, so that it can help people writing Qt applications to navigate through what's available in terms of libraries, frameworks, add-ons, and solutions.

The project I got side-tracked with was ownCloud. A group of people was working on integration with openSUSE and I joined them spontaneously. The result was an ownCloud administration command line client for deploying ownCloud to your local system or to a remote web space. It could easily be extended to also cover use cases like deploying to a NAS system, encapsulating the complexity and all the details you have to remember or read up right now in such a scenario. The code for the command line client is in the administration repository of the ownCloud project on Github and you can easily install the client from Rubygems. As a nice surprise I won one of the hack week prizes, which are given out for the best projects, as part of the ownCloud group.

Hack week is always a source of inspiration and motivation. It's one of the things how SUSE makes a difference. I'm looking forward to hack week 9.

New board members, a user working group, and the Higgs boson

2012-07-07T15:24:00.000+02:00

Akademy 2012 in Tallinn is over. I'm returning to home now. It was a pretty intense week, as usual. But it was a good week. Organization was perfect, and it was feeling like family and meeting friends more than ever. Yay for the KDE community.

Sunset in Tallinn at 11pm

A lot happened in Tallinn. We had an excellent conference. See details on the dot about the first day and the second day, and there will be videos up soon. We had lots of BoF sessions to discuss and work on specific topics. The creativity, dedication, maturity, results-orientation, and pragmatism of the community continues to amaze me. There were also lots of conversations over lunch or dinner, on the hallway, bus, or in between other things. I'm more convinced than ever, that KDE is here to stay for a long time. There is so much value and excellence in the community. There are a lot of good things which will come from this community.

One of the most important results for me was the election of two new members to the board of KDE e.V. during its annual general assembly. It's really great to see that we had more execellent candidates than open positions. Having a good team for the board is very important, and we are in the lucky position that we can sustain this over the years and into the future. So thank you, Celeste and Frank, for the work you did during the past three years, and welcome, Pradeepto and Agustin, to the new board.

Another important results is that we created and endorsed the user working group, proposed by Ingo, Tom, and Ben at the general assembly. Our software is only meaningful, if people are using it, and the relationship between developers and users is not always easy to maintain. So the importance of having a group dedicated to keep users connected to the community, to make sure we have the tools and mechanisms to have productive and enjoyable interaction, can't be underestimated.

Finally a result which wasn't achieved at Akademy, but still excited many people there, was the announcement that the Higgs boson finally was found. It means a lot to me, as I'm a physicist by education, and have worked on ATLAS, one of the experiments which made the discovery, fifteen years ago, when I was working at the university of Heidelberg. This effort over decades, involving thousands of people, experiments on an unprecedented scale, and technology, which sounds like from a bad science-fiction movie, but for real, is truly impressive. It shows what mankind can achieve, when everything goes together.

Thanks to the team of this year's Akademy. You did an excellent job. It was a fantastic event. The city of Tallinn was a great location. Let's see where we will be next year.

Open by default

2012-07-02T08:23:00.000+02:00

KDE is an open community. We are following an open development process, and our structures and processes are intended to be open to contributions and participation.

All our tools are openly accessible, be it our central source code repository, the bug tracker, code review system, mailing lists, or the community Wiki. Even parts which tend to be closed for many other software development efforts, like our release management or marketing activities are open.

The barrier to become a contributor and committer is pretty low. We don't require a contribution agreement, although we do provide the FLA as an option to ensure that the community is able to maintain and defend our code from a license perspective.

Getting commit access to our code repository can happen in a very short time, if people are doing valuable contributions. Once they have access commit access, they have access to the whole repository, there are no hierarchies or technical restrictions based on where people are coming from or what they are doing. We have a strong sense of common ownership of code.

We do have maintainers for the various bits and pieces which make up the software KDE creates. But maintainership is based on merit and respect by peers, not on appointment or formal membership. That creates a very flat structure, where those who do the work decide, and the people doing the best work are taking the decisions.

The formal organization behind KDE, the KDE e.V., has consciously decided to not control development, but leave that to the open community mechanisms, so that it's not some closed group deciding about where the development goes, but the whole community in an open process.

If you consider all this and apply something like the open governance index, KDE scores high on being open. I think it's fair to say, that KDE is open by default.

But we are not perfect yet, and while we have been growing over the last couple of years, one thing became more and more obvious: We are lacking a forum for informing and discussing about non-technical community topics, which are not only relevant for some sub-project or team, but for the whole community.

Some of these discussions are happening on the development or promo lists, or on the KDE e.V. membership list. But this is often not the right place to discuss things which are relevant for a wider group of people. Examples are discussions around how to provide better interfaces between the KDE community and companies, what consitutes a KDE project, or how to better cater to users and non-technical contributors.

So here is a proposal how to address this: Let's create a mailing list kde-community@kde.org as a home for community-relevant information and discussions, which is not technical, with the following charter:

The purpose of the mailing list is to provide a place for non-technical information and discussions which are relevant to the KDE community as a whole.
All people who consider themselves to be part of the KDE community are invited to join.
Conversations on the mailing list are respectful, considerate, polite and constructive.
The list is used to collect announcements and information relevant for the community, which are coming from other sources.
The list is used to collect results and reasoning of discussions which happened in other possibly closed forums.
The list is used to discuss and get feedback on non-technical questions of relevance for the whole KDE community

With this list we can hopefully provide more clarity about what's happening within the community, and make sure that KDE continues to be open by default.

Update: I wasn't clear enough, that all this is not the idea of me alone. Mirko with his talk at Akademy and various other discussions with other people as well are the base for this post. The idea of the kde-community mailing list came from Jos, I think. And this is a proposal, so that we can have an open discussion, not a means to shortcut any debate.

Summer of beautiful installations

2012-06-21T23:06:00.000+02:00

One of my favorite features of openSUSE is the one-click installation. Application authors can put a button on their web site, which brings all the machinery required to allow users to install their application simply by clicking the button. No knowledge about repository URLs, package names, or any other technical details is needed. Just one click.

The build service and the openSUSE software search make heavy use of this feature, and there are also many third party sites, which provide easy installation of software for openSUSE through the one-click installation.

In practice the one-click installation is not exactly one click. The current implementation provides a wizard with a number of steps, where the user can choose packages, import repository keys, and perform the actual installation.

As this isn't the ideal user experience, we would like to have there, Garrett LeSage came up with a new design during one of the openSUSE hack weeks, which which simplifies the installation workflow, hides technical detail, and aims to provide a more beautiful experience to the user installing software.

The idea is to have a simple and beautiful application, which presents one screen showing the state and progress of the installation and offering the user the necessary controls. The focus is on displaying the information, which is relevant and understandable to the user, and making the interaction as smooth
as possible.

As part of the Google Summer of Code 2012, Saraubh Sood is implementing the new design for openSUSE. I'm mentoring him for this project. The code and more details about the project can be found in the Beautiful one-click installer project Wiki on Github.

Saurabh is making good progress. At the beginning there was a good amount of infrastructure and background work to be done. Now we are starting to tackle the user interface. An initial result is already there.

The next steps will be to refine and complete the user interface according to the design mockup and connect it to the backend. There is a decent amount of work to be done left, but it looks like we are on track of having a beautiful one-click installation experience for openSUSE at the end of the Summer of Code.

Beyond that there are a number of things we can do to make the one-click installation system even better. We can further refine the user interface, when we have a working implementation of the new design, and can collect more user feedback. It also would be good to extend the format of the underlying installation descriptions to hav more fine-grained information about which repositories provide which packages, or some automatic selection of repositories based on the version of the distribution the user is installing on. Some more tools to easily generate the one-click install buttons would also be nice.

So there is a bright future for beautiful installation of software on openSUSE. I'm looking forward to what we can achieve over the summer and hopefully see results land in one of the next versions of openSUSE.

ownCloud 4 in a box

2012-05-28T21:15:00.001+02:00

I got distracted by Linuxtag, but finally got around to release ownCloud in a box based on the ownCloud 4 release now. Go and download ownCloud as aplliance in your favorite format now. It's based on the latest ownCloud 4.0.0 release.

For this release I added two new formats, one is Xen, and the other one is OVF, which can be used to run it on VMware ESX. The other formats such as virtual disks for KVM, VirtualBox, Amazon's EC2 and other hypervisors as well as the live images for CDs and USB sticks, or the disk image and the Preload ISO for installation on physical hardware are of course still around.

When you run the appliance in a publicly accessible way, make sure you change the password of the system and ownCloud users. If you use the syncing client, you should also make sure that the machine runs with the correct time, as the syncing algorithm relies on client and server to have the same time.

Setting up encrypted access via https needs the usual configuration of Apache and uploading of a certificate. If you run ownCloud outside your private network and you have private data on your server, this is an advisable step.

It's nice to see all the great progress in ownCloud. But for those who are on the conservative side, there are still the appliances with previous versions around, so you can run proven versions, while you evaluate the new ones. Choose one from the column on the of the ownCloud in a box page.

Releasing Polka 0.9

2012-02-12T13:56:00.000+01:00

I'm at Osnabrück 10, the tenth edition of the annual meeting of the KDE PIM community at the lovely city of Osnabrück. I took the opportunity to put some finishing touches to the next release of Polka. So here it is: Polka 0.9. I consider it the last beta release before releasing 1.0 as first stable release.

It's still an experiment to provide a new view on the user interface of dealing with people. But it works quite stable and well as it is, and you can give the UI concepts a try. Read more about the concepts in my blog entry "It's not an address book". Get Polka 0.9 by checking it out from git or downloading the release tarball: polka-0.9.tar.gz.

I'm happy about feedback, so if you have comments, questions, or ideas, or would like to discuss Polka, please don't hesitate to get in contact.

Finally as a teaser here also is a sneak peek into another world:

It's not done yet, but there is first build running on the N9. The UI needs some adjustments, but the general concept actually feels right on a phone as well.

Introducing Inqlude, the Qt library archive

2011-10-27T15:40:00.000+02:00

Today I would like to introduce you to Inqlude, the Qt library archive. The goal of this project is to provide a comprehensive listing of all existing libraries for developers of Qt applications. So if you are creating applications using the Qt toolkit, and are looking for libraries, components or modules to use, Inqlude is meant to be the place where you find all information and pointers to get started.

The Inqlude project started at the KDE sprint at Randa this summer, where we discussed the idea of a "CPAN for Qt". There is a thriving ecosystem of libraries around Qt, KDE obviously being a big part of it. But there is no easy way to get the complete picture of it, and simply get the libraries which fit your needs best, independent of if they are part of Qt itself, of KDE, or of any other of the numerous places, where people publish their code. Other languages and frameworks have systems for this, like Perl has with CPAN, or Ruby has with Rubygems. So these served as inspiration and I did a prototype on my way back from the sprint on a Swiss train.

During the Qt contributors' summit, the desktop summit, and recently this week at the Qt contributors' day at the Qt DevDays in Munich, we had more discussions about it, collected feedback on the prototype, and refined the concept. During the last SUSE hack week I sat down to bring the code and the web site up to an alpha state, where it could serve a useful starting point for the project, for application developers to find libraries, and for library authors to contribute data about their projects.

The main component now is the web site. It's listing the data about Qt based libraries. These are only pointers, there is no hosting of code or packages involved. Inqlude is not meant to duplicate any of the functionality of code hosters, or distribution packaging systems, but integrate well with what's already there.

The meta data is stored in a git repository. So it's easy to contribute, following the well-known procedures of submitting patches. More information can be found on the "how to contribute" page on inqlude.org.

In addition to the web page, there is an inqlude command line tool. This can be used to get libraries and install them locally. Right now it's a prototype. It works with openSUSE 11.4 using the openSUSE build service as source. In the future we'll add more backends for other distributions and add more information about packages, so that you can easily install the libraries you need. Again this is not meant to duplicate any existing tools, so we'll make use of the native package management stacks and build tools which are already there.

The command line tool is inspired by the Ruby gem system, which makes it amazingly easy to distribute and get software. The inqlude command line tool prototype uses this mechanism itself. See the instructions how to get and use it on the inqlude.org page for more details. With C++ it's of course more difficult to distribute software, because there is a build step. But here comes the open build service to the rescue, which takes care of this step.

So what's next? This blog marks the official beginning of the alpha phase. The general structure of the web site is in place. So the next steps are to complete the collection of library data, and make the web site ready for end users. When this is done, we'll enter the beta phase. The goal of this phase will be to make the command line client ready for end users. Then we'll release Inqlude as 1.0, ready for production use.

If you want to help, you are more than welcome. Just go to the inqlude@kde.org mailing list. There we'll coordinate development, collect data, discuss, and help, if you have questions. See you there.

Fifteen years of KDE

2011-10-14T10:06:00.000+02:00

Fifteen years ago Matthias Ettrich started the KDE community. On 14th October 1996 he wrote his famous email to the de.comp.os.linux.misc group on Usenet. He called for other programmers to join him to create a free desktop environment for Linux targeted at end users. Many, many people joined. Thousands of developers wrote millions lines of code. We did 90 stable releases of our core set of applications alone, not counting all additional stuff and the thousands of 3rd party applications.

So now, fifteen years later, we are done. We have a wonderful free desktop environment for Linux which is used by millions of users every day. Well, are we done? Not quite. While we have reached the original goal of creating an appealing desktop which makes Linux accessible to everyone for everyday tasks, our scope has broadened. There are whole new classes of devices in need of free and friendly user interfaces, it's not only the desktop anymore. The cloud presents new opportunities for connecting computers more than ever, and presents new challenges for freedom of software and data.

We are on it. The last two weeks saw frentic activity in the KDE community. Last week we released version 4.7.2 of our flagship product, the classical desktop. On Sunday we released Plasma Active One, our speedboat going into the waters of tablets and the device spectrum. On Tuesday we released ownCloud 2, our helicopter going into the cloud on its mission to retain your freedom and control about your data.

The KDE desktop is part of our live. We and millions of others use it every day. It's great for getting work done. We are on par with other desktops, but we are still pushing the limits and innovating, for all the users out there. This won't change anytime soon.

Plasma Active is one of the results of our innovation activities. It brings KDE to tablets, and it comes with a strong vision to create an elegant, desirable user experience for a spectrum of devices. It builds on the foundation of the KDE software, but it opens new doors, explores new areas. I'm really looking forward to what we can achieve there.

ownCloud goes beyond what we have done before. It runs in the cloud. But it's built on the values and the community of KDE. We deeply care about software freedom. Enabling users to retain control about their data and their privacy is a big part of that. ownCloud does that where other cloud solutions fall short. It brings fresh blood and energy, and opens up a space, which we weren't able to address before. Here as well I'm looking forward to what we can do.

Fifteen years of KDE is a long time. I joined the community in 1999, and I can say that KDE changed my life. I probably wouldn't have the job I have today without KDE, I wouldn't live where I live today, and I would miss a lot of great experiences and friends I wouldn't have met. In the interview I gave for the "people behind KDE" series, there was a question, what my favorite feature of KDE was. My answer was: "the community". Many other KDE people answered the same.

That's the core. KDE is an awesome community. I'm proud to be part of it, and I'm looking forward to be part of it for the next fifteen years of KDE.

The demise of the Windows platform

2011-10-13T09:09:00.001+02:00

I bought a Windows game last week. What I got was a scenic tour through the demise of the Windows platform. I knew that Windows as gaming platform was troublesome, but it never was as clear that it's actually moving towards irrelevance. If you ever have seriously played games on Windows you know this cocktail of driver updates, googling error messages, entering illegiible cryptic codes from stickers hidden in game boxes, waiting for online activation, going through update popups of various origins, and what not. It took me something like two hours before I was even able to start the game. I love games, and I have played quite some games on Windows, but I might be done with this now.

Of course Windows as a platform won't go away anytime soon. There are hundreds of millions of people running it. But the interesting part is that there are less and less reasons to do so. One of the arguments why people don't use Linux on their desktops always was "I need Windows to run my games". I heard this a thousand times. But as this argument becomes irrelevant, the only argument left is "I have always run Windows".

The free Linux desktop is mature. It's not only on par with proprietary desktops on other operating systems, it actually is innovating and moving beyond what other systems do. It covers all the needs of the vast majority of use cases. It has a variety of office suites, it runs several fine web browsers (another area where Windows has lost relevance up to the point of being made fun of), it has excellent tools and applications in almost any area you can think of, it's a primary choice for software developers, it even moves beyond classical desktops to netbooks, tablets, and more.

In addition the free desktop has some inherent attributes where Windows just can't compete, first of all the software freedom, but also the development model, and the distribution ecosystem. When you install a Linux desktop you have a fully functional system, you can browse the web, you can send email, you can edit your spreadsheet, even printing works out of the box these days. When you have Windows installed you are at the beginning of an odyssey to add all the bits and pieces you need to have make your system functional and secure.

Some might argue, that the desktop itself is becoming irrelevant. For some areas that might be true. People will use their phones or tablets or game consoles for things they have done on a desktop before. But there are so many people using their computers for work and other serious things, where you do want to have a solid desktop, probably not exclusively, but it won't go away for a very long time.

You might also argue, that people are using web applications instead of desktop applications. This also might be true in some areas. But the interesting part is that web applications have developed into another kind of desktop applications. The platform is different, it's Javascript and the web client environment, and the apps are heavily connected to web services. But you absolutely need a solid platform on your local system to be able to run the web apps. This platform is more than ever based on Linux (think Android), and there is no reason why this shift shouldn't continue to happen very quickly.

KDE is in an interesting position here. We are one of the key players on the free desktop, we have a mature classical desktop, we are expanding to other form factors and into the web, we have a strong community, which can make things happen, nobody would have expected to be possible (or who thought that Matthias announcement from 15 years ago would result in something like we have today).

We even have a story on Windows, where we have central applications like Kontact or Okular, which are more than a replacement for the apps, which are only running on Windows. This is more important than ever as a migration strategy. It's very easy to arrive at a point, where all the applications you run on Windows, are actually running natively on Linux as well. Running LibreOffice, Firefox, and Kontact on Windows? Fine, move over to Linux, it will run as well and better, and you will enjoy the freedoms of free software.

We have a chance to change the world, let's do it.

SUSE hack week

2011-09-25T21:56:00.001+02:00

Hack week. One week of ferocious hacking on new ideas without interruptions. SUSE does this twice a year to trigger those innovations, you can't realize when you are swamped by day-to-day work. Of course it's not the only way or opportunity to do new things, but it gives the freedom to actually get something done on a topic, which is not covered by conventional product planning. It's productive, it's fun, it creates great results. Next week it's the seventh edition of hack week. We are collecting ideas and activities in openFATE.

Nat started the first SUSE hack week four years ago. Others followed suit. This is quite a bit of history. So I was thinking of what I did the six times before, and what I want to do at the seventh time. Here is a summary. My hack week blog, which I usually use to report about my hack week progress, has some more details.

Hack week 1: Dynamic web services portal

In the first hack week I tried to put a dynamic web services portal together based on enriched ("activated") Atom feeds. The goal was to collect information from various source like Bugzilla, Email, FATE, Blogs, aggregate them and offer actions to work on them, such as closing a bug, responding to an email, but all from one uniform view. I wasn't able to really get this project off the ground, as I was spending quite some time on helping others, watching, what was going on, and discussing ideas. A week probably also was too short for the ambition of this project. But it was an interesting attempt, and failure is an option at hack week. Others were more successful. Ars technica has a nice piece "Novell Hack Week: an experiment in innovation" with lots more details.

Hack week 2: KDE 4.0 beta

In the second hack week a couple of KDE hackers at SUSE teamed up to bring some parts of KDE 4.0 into shape for the beta release. We took a big office sat down together and worked on various parts of KDE to make it ready for the next beta release. I did a dive again into the KOrganizer code, fixed some bugs, cleaned up the code, did some porting work, and more. It was a very targeted effort, and it was great to work in a team.

Hack week 3: Social desktop

The social desktop project was one of my most successful hack week projects so far. Again it was a team effort. Frank Karlitschek, Sebastian Trüg and Dirk Müller joined me to work on the implementation of some of the social desktop ideas Frank had presented at his Akademy 2008 keynote. While Frank was working on the server side I was implementing libattica as client library to provide social desktop features via the open collaboration services protocol. We got quite a bit of work done, and the project won a 3rd prize as best overall project at hack week. There is an interview, which was taken at Hackweek III, where I give some background and also talk about some other stuff around my work.

It's great to see that the project is still alive and kicking today, several years later. The protocol and the client library I started are widely used now, and it's used as base for many different use cases, such as downloading wallpapers, providing a software shop, or updating Plasmoid backends. It's awesome when ideas pan out.

Hack week 4: KDE SDK

For hackweek 4 I thought I would try a big, ambitious project, I wanted to do for a long time already, provide an integrated, easy-to-use kit for KDE development. Taking great components like Qt Creator, using wonderful tool like the build service and SUSE Studio, I wanted to put together a software appliance, which could easily be used to develop KDE programs out of the box without much setup effort. I wrote a Qt Creator plugin, added KDE templates, did some services integration with git and opendesktop.org, and put everything together in an appliance. I got a lot of good feedback on the concept, but it was more work than I could do in a week, and I wasn't able to follow up later, so it's still an unfinished project. Would be great to eventually take it up again.

Hack week 5: SUSE Studio GUI client

SUSE Studio has a nice API, which can be used to control all the various aspects of appliance building and publishing. For the fifth hack week I decided to implement a GUI client for SUSE Studio using this API. It also gave me the opportunity to hack a bit on kxml_compiler, which is part of Kode, my multi-year side project for handling various aspects of XML in C++ in an easy way. I made quite some progress and had a client able to run test drives with native integration in the UI. I didn't find time to continue to work on this project after hack week, though, and there are other clients now as well. I'm not sure how much future this project has.

Hack week 6: Polka, the humane address book for the cloud

This was my most ambitious hack week project so far. I fundamentally rethought how I approached address book applications, and came up with a concept based on user's view on people from ground up. I called it a humane address book for the cloud. I had thought about that quite some time already, and also had written some code. But hack week gave me the opportunity to really bring it to a state, where I could share it with others. The feedback was amazing. One of my favorite responses was "I saw the future". Polka now is in a state, where it's actually useful, and I did a first release during the last openSUSE conference. This project has a bright future, I'll definitely continue to work on it.

Next hackweek: Qt library archive

This is my plan for hack week 7. Get the Qt library archive project beyond the prototype state. This started at a KDE sprint in Randa, was continued at the Qt Collaborator's Summit, got some more discussions at the Desktop Summit, and now needs some work to be taken to the next level. 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. If you are interested in joining me to work on this, don't hesitate to ping me. These are the things I plan to work on:

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 packages, which aren't
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.

My openSUSE conference

2011-09-22T14:03:00.000+02:00

Last week was the openSUSE conference in Nürnberg. Here are some of my impressions. I loved the relaxed, crazy atmosphere, mixing so many different people with so many different backgrounds, skills, interests, and fascinating projects. This spans quite a broad range of topics, not only on the software side from kernel to office suite, but also in other areas from cheese over quadrocopters to self-replicating machines. This community is seriously rocking the boat.

I gave two presentations at the conference. The first was about Polka, my humane address book for the cloud, which I mostly wrote during the last SUSE hack week. I explained the concept of addressing the problem from the user's side, not from an implementation point of view. Humans don't think about people in terms of vCards, but in terms of groups, pictures, time, and space. The Polka user interface reflects that.

I also did the first release of Polka during my presentation live on stage. So if you want to try it, go to the Polka home page and download the tarball. It's an early release, but it should work quite well. I intend to stabilize it a bit more and then do a 1.0 release. If you find bugs, please let me know.

The other talk I gave was a lightning talk in the Speedy Geeko session. Twenty slides in five minutes. This was fun. There were a nice variety of topics, including bees, fire fighters, and crazy scotsmen. My talk was about Maria Montessori, the Italian educator, who founded the Montessori schools. A lot of the concepts from her philosophy of education have interesting parallels in what we do in open source development.

There were many more talks. I only had a chance to listen to a few of them, but I enjoyed Greg's talk about the Kernel and Tumbleweed (change faster to be more successful), and Martin's talk about Wayland (wait until it's done, and then wait some more). Dominik showed the latest from SUSE Studio in a presentation and we also had the kiosk at the venue, which always is a great way to show, explore, and explain Studio.

Another great thing was that there were so many KDE people at the conference. It shows the strong relationship of openSUSE and its upstream projects, and KDE makes some excellent use of openSUSE, e.g. as base for Plasma Active. This is a great fit, and I think it's hard to underestimate how important collaboration between downstream and upstream is. We'll only win together.

Finally it was great to feel the enthusiasm of the community, people who came from all over the world, hang out at the barbecue in the evening, listen to 8-bit music, drinking openSUSE beer and chatting about openSUSE and many other things. The Zentrifuge was a wonderful venue for that. It certainly was an inspiring event. When is the next conference?

Back from Berlin

2011-08-16T15:49:00.000+02:00

I'm back from the desktop summit, back from Berlin. It was an intense event, lots of great people, lots of great content. So I arrived at home tired, but inspired. Read on for my personal conclusion.

The conference was excellent. All the presentations I saw were of high quality. It also turned out to be exactly the right thing to put everything into one program, independent of affiliation of speakers or targeted community. I enjoyed the opportunity to learn more about some projects I'm usually not following that much. It was also great to have presentations done jointly by people from different communities, like the one from Lydia and Seif, or the upstream/downstream discussion led by Vincent, or the intern show case lightning talks.

One of the highlights of the conference was the panel discussion about copyright assignment. It's a complex topic, but the panelists brought up good arguments and lot of food for thought. Mark spoiled his argumentation a bit at the end by introducing his generosity concept. This certainly has its place when talking about motivation in a community, but in the context of legal agreements with companies it's very questionable, if generosity should be a dominant concept. My takeaway from the panel and some other discussions I had at the summit is that KDE e.V. is in a very good position here with the Fiduciary License Agreement, we optionally provide for KDE contributors. This provides a good balance of the different interests and adds safety for contributors and community.

The other big thing at the desktop summit was the general assembly of KDE e.V. It was a very focused and organized session. Mirko led it in record time. Lydia was elected as new board member replacing Adriaan, and I was reelected for my third term. In the afternoon we had a good BoF session about KDE e.V. questions, and we had a very good discussion about how to involve more people in KDE e.V. work. There is a lot to do, which is very important to be able to sustain the support for the community, expanding the individual supporting membership program, managing relations to existing and new corporate partners, maintaining our trademarks, keeping up and improving our infrastructure for sprints, membership, and KDE e.V. work, the next Akademy, and much more. We will do a KDE e.V. sprint later this year to get some work done on these topics, and to involve more people beyond the members of the board.

The last part of the desktop summit was the workshop week. It was packed. It felt more busy to me than at any previous event. There was a lot going on. The experiment with showing all KDE sprints of the last year in one hour worked well. We had 21 lightning talks and it was impressive to see, what happened there, how many people spend their passion and skills on these focused events. It can't be underestimated how much energy they put into the community, and how much things get done or triggered when you put a bunch of KDE people in the same room for a long weekend. For next year, I'll try to put this kind of session into the main conference program, as it really deserves to be shown to a big audience.

Another nice trend from the sprints became more visible. Several people used Kanban as a method to organize, visualize, and track the work done at sprints. Kevin introduced it a while ago, and the feedback to that is very positive. It's a low tech method of managing the activities at a sprint by basically putting sticky notes on a wall. By providing some simple rules for the flow of these sticky notes through the different stages of work being done, and applying constraints to how much work is going on in parallel, it's possible to maintain some good flow. Things get done quicker and it's easier to adapt to new things coming up. I think Kanban works best for the longer sprints, where you have more than just two short days on a weekend, but it's certainly worth experimenting with it as it's designed to adapt to different needs by modifying the rules and constraints as needed.

Finally I noticed two trends, which I really welcome. First is that there seems to be a growing interest in usability and design. We had design keynotes. It was said in many talks that people were looking for more involvement with designers. Technologies like QML provide new ways to involve designers and design thinking. There were usability BoFs and lots of discussion about how to better address users's needs. The second trend is that there seems to actually emerge a convincing story for KDE on devices beyond the desktop. Plasma Active is spearheading this, and many people are able to contribute there now with the ExoPCs Intel gave out for development. It could be called a mobile story, but it's more than that, because many of the concepts work on desktops as well, so it's rather about addressing the spectrum of devices we are talking about for quite a while now. This goes well with the first trend about focusing more on design, as we are exploring areas, where there don't exist many strict concepts about how to do things, and it could be seen as closer to the user as some of the other areas we are active in. Lot's of interesting stuff is happening here. I'm looking forward to what we will be able to come up with in the next future.

Last but not least I was really impressed by the work of the volunteer team. They did an amazing job in making the event run very smoothly. This, together with a great venue and the support of the university, the city, and all the sponsors, provided the perfect environment for the community to have a productive and enjoyable time. The volunteer team also showed how much we can reach, when KDE and GNOME people are working together. It sets a high bar for future events. Thanks a lot to everybody involved.

One year of KDE sprints

2011-08-08T13:11:00.000+02:00

On Wednesday we'll do the experiment to present all KDE sprints which happened within the last year in one hour. We have speakers lined up, slides prepared, and just need you to come and listen. The session is happening on Wednesday, August 10th, at 10am in room 1.205 here at the desktop summit. See the workshop program for more details.

We had such a great set of no less than 21 sprints over the last year. So it will be exciting and fun to see a compressed version of that in one go. I'm looking forward to see you at the session on Wednesday.

Approaching the desktop summit

2011-08-04T22:28:00.000+02:00

It's only one day left until the global KDE and GNOME communities meet at Berlin for the second desktop summit. Hundreds of free software contributors from all over the world, the core of the free desktop community is meeting at the Humboldt-Universität zu Berlin in the middle of the German capital from August 6th to 12th.

It's those people who create the software, which millions and millions of users see, feel, and use every day, on the desktop and beyond, who make great technology accessible to everybody. Many of you participate in this effort, and by doing this with free software we are providing nothing less than one of the building blocks of free society. Getting all the creative minds, the people with passion for beautiful, elegant, powerful, amazing software, together at one event, that's remarkable, and I'm looking forward to what we'll breed at Berlin, what ideas, collaborations, what code will emerge.

For me one of the most important parts of the desktop summit will be the general assembly of KDE e.V. Without KDE e.V. events like this wouldn't be possible. It provides the organizational foundation, which is necessary to run a community on the scale KDE has reached. The general assembly is the annual check point, where we report and reflect on the state of the organization, and decide about its future direction. As a member of the board it's my duty and my honor to report on what we have achieved.

This year is a bit special as we'll have elections for two of the five board positions, and I'm running for my third term. While we have achieved a lot with KDE e.V. over the past years, we are still in a position, where we have the chance to achieve a lot more, for the KDE community, for free software, and, as already said, for a free society in general. To make some of this happen is one of the main goals I have for my third term. I need your support and your help for that, and I hope we can build an even stronger organization, where many of you join the effort of making the world a better place through our technology.

The main part of the desktop summit of course is the conference. We have a great lineup of keynote speakers: Thomas Thwaite, Claire Rowloand, Dirk Hohndel, Stuart Javis, and Nick Richards.We have dozens of other presentations, which cover the whole spectrum of the free desktop, technology, community, from both, the KDE and GNOME communities, and related project. If you are interested in free software on the desktop and reaching beyond the desktop, there is no better place to be than Berlin next week. As a special highlight we have a panel about copyright assignment with Mark Shuttleworth, Michael Meeks, and Bradley Kuhn, moderated by Karen Sandler. This is going to be interesting. KDE has a clear position there with the fiduciary license agreement we created with the help of the FSFE, which preserves freedom, gives equal rights to contributors, and doesn't create any barrier of entry.

The other big part of the desktop summit will be the workshops and BoF sessions, the less formal events, which take place towards end of the week. This is where people have time and opportunity to mingle, to collaborate, to exchange ideas, to discuss projects. I'm running an experiment there, the attempt to cover a full year of KDE sprints in one hour. We'll have a series of lightning talks giving an impression of what happened at the 21 sprints we had since Akademy a year ago. I'm also looking forward to discuss and finalize the recommended KDE git workflow we came up with at the sprint in Randa in June. Finally I also intend to move forward with the idea of a Qt library archive, which also originated at Randa, and which we discussed in more detail at the Qt contributors' summit.

As always I'm also carrying the hat of my employer, SUSE. openSUSE is a great distribution to run both KDE and GNOME, and SUSE Studio, my main project at SUSE, also can be useful in the context of the desktop communities in various ways. If you are interested in any of that, would like to discuss it, or need help getting something done, don't hesitate to talk to me.

Tomorrow I'll board a train and go to Berlin to dive into this special sphere of the free software community again. It's my ninth of the big annual events organized by KDE, be it Kastle, Akademy, or the Desktop Summit. I can't wait to meet all the old and new friends who make up this wonderful community.

See you in Berlin.

KDE 4.7 release party in Nürnberg

2011-07-26T12:05:00.000+02:00

Following the motto "Think Global, Party Local", we'll have a KDE 4.7 release party in Nürnberg on Wednesday, 27th July. It will take place at the SUSE offices, starting at 19:30, and we'll have a few short talks, and the opportunity to chat, have some beers, and celebrate the latest KDE release. If you happen to be in Nürnberg and would like to meet some of the local KDE guys, you are very welcome to join. See the community wiki for the details.

Putting things together

2011-06-27T00:22:00.001+02:00

Half a year ago there was a thread on the kde-core-devel mailing list with the topic "why kdelibs?". I gave a potential answer and this resulted in a series of great discussions. While these discussions were very constructive, it was pretty clear, that we would need an in-person meeting to finally answer the question about the future of the KDE platform.

At the same time Mario was preparing the third KDE developer meeting at Randa, Switzerland. It began with a Tokamak sprint in 2009, continued with a combined KDE multimedia and KDE edu sprint, and for 2011 he was preparing a triple sprint with KDE multimedia, KDevelop, and Nepomuk. Mario put up with the adventure and offered to host another sprint as well, so we put things together and added the Platform 11 sprint to the list.

The sprint ended two weeks ago. It turned out to be four and a half sprint in one, with the kdenlive gang joining us for some extended hacking fun. Almost sixty KDE people were in the middle of the Swiss mountains, coding, discussing, and plotting the future. It was an inspiring and productive event, thanks to the hospitality of Mario and his team (including his family), thanks to the incredible energy, which is unleashed, when KDE people get together. I have been at many sprints over the last years, but it still amazes me every single time, that it immediately feels like meeting old friends, even if you have never met the people in person before. But it's more than just a bunch of friends. It's a group of professionals, putting an incredible amount of passion, creativity, and talent into KDE. This makes these kind of events unique and it's stunning what can be achieved there.

For me the most important result of the Platform 11 sprint was the consensus we built about where we want to move the KDE platform. It's about making the components we provide more accessible to developers, expanding our reach, and cleaning up our technology. We'll go with more modular frameworks with less dependencies, which can be used naturally along other Qt libraries, and a release process which will deliver our work quickly. More details are described in a series of mails about the future of our frameworks from Sebas, the intended organization of our frameworks from Kevin, a plan to transition to KDE frameworks from David, and the KDE git workflow from me, on the kde-core-devel mailing list. To reflect the changes we'll refer to the KDE libraries and required runtime components as the KDE Frameworks in the future and retire the use of the platform term. This expresses well, that KDE provides utility for building great applications, but isn't tying users or developers to a monolithic block of dependencies.

What happened to the idea of merging the KDE development platform and Qt? It was a radical idea to trigger some thoughts, not a plan how to actually proceed. The main goals behind the idea, to make the KDE libraries more accessible, lower the barrier for developers using the libraries, to remove redundancies, to clean up the developer story, grow the developer community, and provide a consistent story to users, they still hold. A lot of what we discussed at Randa goes into this direction. Libraries will become more self-contained and we'll try to put quite some code into Qt. For a full merge neither Qt nor KDE are ready yet, so I think it's a good solution for now, to work on the concrete plans we came up with at Randa along the goals of making the KDE frameworks more easily accessible and available to a wide audience of application developers.

The other sprints happening at Randa also created impressive results. The multimedia guys were putting together the bits and pieces around Amarok, Phonon, PulseAudio, and KMix, and kdeenlive joined the KDE community. At the Nepomuk sprint the Zeitgeist and Nepomuk developers came up with a plan how to integrate their technologies, putting together the best parts of semantic technology on the free desktop. The KDevelop group was tremendously focused, they weren't really visible to me. When I was leaving Randa I met Alexander Dymo at the train station, as we took the same train, and he told me that they managed to check off all their todo items during the sprint. That's impressive, and it reflects the spirit of the Randa meeting.

We had a great mix of people at Randa, KDE dinosaurs and fresh blood, people central to the community for years, and people just joining. We had some friends from the GNOME community there, and we had local people being interested in what we were up to. Even when taking a walk through a bit of the mountains around Randa, we met people interested in what we were doing and ended up discussing KDE.

In the end to me the dominant theme of the meeting was putting things together. We did that with our plans for the KDE frameworks, we did that with various parts of the community, we did it with our relation to other communities, and of course we put quite some code together on top of all that.

More Polka, please

2011-06-05T21:19:00.000+02:00

After blogging about Polka, my experiment with a radically new take on an address book, I got a lot of great feedback. I appreciate all the comments, questions, and encouragement. Two people made me particularly happy, as they not only sent feedback, but also contributed some welcome work. Sascha Manns built packages, and Saleel Velankar created a beautiful logo. Free software rocks.

When I started with Polka, one of the main ideas was to not do a traditional desktop user interface, but try out something more natural. One of the side thoughts was that this kind of interface might also work well on some non-desktop devices, for example on devices with a touch interface. But I didn't really know, if it would work. So I decided to try it out.

My first attempt resulted in a port of Polka to MeeGo. MeeGo is a system targeted at touch interfaces, and being Qt based it seemed to be close enough for a getting Polka to work on it. It took me a while to get a working development environment set up, but thanks to Google, and careful study of a bunch of Wiki pages, I finally was able to create MeeGo packages with QtCreator and run them in an emulator.

Porting Polka then was not a huge effort anymore. The proven approach of bundling it with a mini version of kdelibs covering only the functionality required by Polka on MeeGo worked out well again. So here is Polka Touch.

Unfortunately I didn't have a MeeGo device, and the emulator only gives a very limited impression, of how the user interface works. So I needed real hardware, and luckily I came across some cheap WeTab.

The WeTab comes with some version of MeeGo, but I didn't bother with trying to build packages for it, but installed openSUSE. Again some Googling and studying of Wiki pages was required, but then openSUSE ran on the WeTab like a charm. The WeTab might not be the greatest tablet hardware from an end user's perspective, but for a developer it's great. I even was able to compile Polka directly on the tablet.

So how does Polka work on a tablet with a touch interface? It works surprisingly well. Arranging people by moving them around on the canvas feels even better than on the desktop. The menus work well, not using traditional desktop menus definitely is a win here. The dialogs for input of data, are not that great, but it should be straight-forward to adapt them to some more native method to gather data from the user. Another thing which needs some improvement is the use of the canvas background to show a menu for adding labels. This is easily activated accidentally by just touching the screen. It would be better to support scrolling the canvas with touching the background. This might even be interesting on the desktop version.

Overall I have to say it's fun to use Polka on a tablet. Still needs some tweaks, but the first experience is already quite good. It's nice, when ideas work out.

Platform 11 at Randa

2011-06-03T08:57:00.000+02:00

I'm at the Platform 11 sprint at Randa. We are here to discuss and shape the future of the KDE platform. It's the first meeting of this kind since Trysil five years ago. Four people who were at Trysil also made it to Randa, including a respectable dinosaur, but it's great to also have new and very new faces around.

Randa is a great location. It's a small village in the south of Switzerland, in the middle of the mountains. The Swiss railroad system did an impressive job of bringing us to Randa on a steep and winding track. Now we are surrounded by thousands of meters of mountains, and there is snow and glaciers, but no escape. Perfect time to focus on the KDE platform.

Yesterday we did a brainstorming and collection of topics to discuss, and started to go into projects in smaller breakout groups. A Kanban board keeps us on track and moving. There is a lot to discuss, but it's already pretty clear, that there is a solid base of consensus on many of the core questions, how to make kdelibs more modular, how to better seperate and define the framework and the platform, how to lower the barrier for application developers. We will need to do lots of additional work to sort out details and find the best solutions to the key questions, but that's what we are here for. So I'm looking forward to the next few days, and all the results we'll create.

Show us your work on the free desktop

2011-03-24T13:01:00.000+01:00

The deadline for the Call for Participation of the Berlin Desktop Summit is approaching. The deadline for submitting proposals for presentations and lightning talks is tomorrow. So you still have the chance to submit a presentation and talk about your work on the free desktop at the wonderful event in Berlin that the desktop summit promises to be. It takes place from 6th to 12th August this year and combines the annual conferences of the KDE and GNOME communities.

Some of you might think that your contributions to the free desktop to the event are not relevant enough to warrant submitting a talk. That often is not true. While we will have well-known speakers who have done ground-breaking things on the free desktop, we all have started small, and sometimes especially the small projects, which are still young, are the most interesting ones to hear about. So please don't hesitate to try it, submit a presentation, talk about the projects you are passionate about, share the love for the free desktop with the community. Berlin is the right place for this.

Submit your proposal now.