Wednesday, December 19, 2012

Human-Computer Interaction Class

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.

Friday, November 30, 2012

Fifteen years of KDE e.V.

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 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.!

Thursday, October 11, 2012

ownCloud 4.5 in a box

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!

Monday, September 17, 2012

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

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, 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

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 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.

Saturday, July 7, 2012

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

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.

Monday, July 2, 2012

Open by default

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 repositorythe 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 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.

Thursday, June 21, 2012

Summer of beautiful installations

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.

Monday, May 28, 2012

ownCloud 4 in a box

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.

Sunday, February 12, 2012

Releasing Polka 0.9

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.

Governance on demand

I have talked about the Spectrum of Open Source Governance Models  before. After rereading Nadia Eghbal's excellent post Governance with...