Thursday, December 12, 2013

ownCloud 6 on openSUSE 13.1


ownCloud and openSUSE are two of my favorite projects. After they both have released major new versions I have updated my ownCloud in a box appliance now, so that it's easy to get the latest and greatest what ownCloud and openSUSE have to offer. The appliance is built with SUSE Studio as usual and comes in a variety of formats to allow installation on physical and virtual systems, running it from live media, or deploying it to the cloud. Check it out on SUSE Studio's gallery.


One of the big new features of ownCloud 6 is ownCloud Documents, a collaborative editor based on ODF. This is a pretty cool feature as it allows groups of people to work together on a document with rich text. The best is that it's all free and open and you can run it on your own server so you have full control about your data.


There is much more. Read on about what's new in ownCloud 6 and what's new in openSUSE 13.1. Congratulations to both projects for two fabulous releases. I'm looking forward to more to come.

Sunday, November 10, 2013

One place to collect all Qt-based libraries

A few weeks ago, during SUSE Hack Week 10 and the Berlin Qt Dev Days 2013, I started to look for Qt-based libraries, set myself the goal of creating one place to collect all Qt-based libraries, and made some good progress. We had come up with this idea when a couple of KDE people came together in the Swiss mountains for some intensive hacking, and where the idea of Inqlude, the Qt library archive was born. We were thinking of something like CPAN for Qt back then. Since then there was a little bit of progress here and there, but my goal for the Hack Week was to complete the data to cover all relevant Qt-based libraries out there.


The mission is accomplished so far. Thanks to the help of lots of people who contributed pointers, meta data, feedback, and help, we have a pretty comprehensive list of Qt libraries now. Some nuts and bolts are still missing in the infrastructure, which are required to put everything on the web site, and I'm sure we'll discover some hidden gems of Qt libraries later, but what is there is useful and up to date. If some pieces are not yet, contributions are more than welcome.

Many thanks as well to the people at the Qt Dev Days, who gave me the opportunity to present the project to the awesome audience of the Qt user and developer community.

Format


The first key component of the project is the format for describing a Qt-based library. It's a JSON format, which is quite straightforward. That makes it easy to be handled programmatically by tools and other software, but is also still quite friendly to the human eye and a text editor.


The schema describes the meta data of a library and its releases, like name, description, release date and version, links to documentation and packages, etc. The data for Inqlude is centrally collected in a git repository using this schema, and the tools and the web site make use of it to provide nice and easy access to users.

Tools


The second key component is the tooling around the format. The big advantage of having a structured format to describe the data is that it makes it easy to write tools to deal with the data. We have a command line client, which currently is mostly used to validate and process the data, for example for generation of the web site, but is also meant to help users with installing and downloading libraries. It's not meant to replace a native package manager, but integrate with whatever your platform provides. This area needs some more work, though.


In the future it would be nice to have some more tools. I would like to see a graphical client for managing libraries, and integration with IDEs, such as Qt Creator or KDevelop would also be awesome.

Web site


The third key component is the web site. This is the central place for users to find and browse libraries, to read about details, and to have all links to what you need to use them in one place.


The web site currently is a simple static site with all its HTML and CSS generated from the meta data by the inqlude command line tool. Contributing data is still quite easy by providing patches to the data in the git repository. With GitHub's web interface you can even do that just using your web browser.

Notes


There are a few things worth pointing out explicitly as I got similar questions about these from various people.

The first thing is that Inqlude is meant to be a collection of pointers to releases, web sites, documentation, packages. It's not meant to host the actual code, tar balls, or any other content belonging to the libraries. There are plenty of ways how to do that in a better way, and all the projects out there already have something. Inqlude is just meant to be the central hub, where to find them all.

Another thing which came up from time to time is the question of dependencies. We don't want to implement yet another package management system, or another dependency resolver. So there we rely on integration with the native tools and mechanisms of the platforms, we run on. Still it would be nice to express dependencies in the meta data somehow, so that you have an easy way to judge, what you will need to run a given library. We will need to find a way how to do that in the best way, maybe a tier concept, like KDE Frameworks 5 is using it, would do the trick.

Finally I would like to stress that Inqlude is open to proprietary libraries as well. The infrastructure and the tooling is all free software, but Inqlude is meant as an open project to collect all libraries which are valuable for users on the same terms. The license is part of the meta data, so it's transparent to users, under which terms the library can be used, and this also allows to categorize libraries on the web site according to these terms. There still is a little bit of work missing to do that in a nice way, but that will be done soon. Free software libraries of course do have the advantage, that all information, code, and packages, is directly available, and can be accessed immediately.

Future


There are a couple of short term goals I have for Inqlude, mostly to clean up loose ends from the work which happened during the last couple of weeks:

  • Collect and accurately present generic information about libraries, which is not tied to a release. This is particularly relevant for providing a place for libraries, which are under development and haven't seen a formal release yet.
  • As said above, the listing of proprietary libraries needs some work to categorize the data according to the license. Then we can display libraries of all licenses nicely on the web site.
  • Currently we have one big entry for the Qt base libraries. It would be nice to split this up and list the main modules of Qt separately, so it's easier to get an overview of their functionality, and use them in a modular way.

There also are a number of longer term goals. Some of them include:

  • Integration with Qt Designer, so that available libraries can be listed from within the IDE, and being used in your own development without having to deal with external tools, separate downloads or stuff like that.
  • Build packages in the Open Build Service, so that ready-to-use binary packages are available for all the major Linux distributions. This possibly could be automated, so that ideally putting up the meta data on Inqlude would be all what it takes to generate native packages for openSUSE, Fedora, Ubuntu, etc.
  • Integration with distributions, so that libraries can be installed from inqlude via the native package management systems. This already works for openSUSE provided the meta data is there, but it would be nice to expand this support to other systems as well.
  • Upstream the meta data, so that it can be maintained where it's most natural. To keep the data up to date it  would be best, if the upstream developers maintain it at the same place and in the same way as they also maintain the library itself. This needs a little bit of thought and tooling to make it convenient and practical, and it's probably something we only want to do when the format has settled down and is stable enough to not change frequently anymore.

There might be more things you would like to see to happen in Inqlude. I'm always happy about feedback, so let me know.

This was and is a fun side project for me. It's amazing what you can achieve with the help of the community and by putting together mostly existing bits and pieces.

Thursday, October 10, 2013

Inqlude progress

My Hack Week project is progressing. Qt Dev Days have finished. I presented Inqlude there and got lots of good feedback. I even won a prize for my lightning talk. Thanks a lot for that.



I got a lot of input on which libraries were still missing and have a pretty long list to process now. The patches I got on GitHub I have already merged. Tomorrow I intend to go through the rest of the list and add the missing data. This should get us a lot closer to the goal of having all Qt-based libraries listed in one place.

One question came up a few times. Do we also want to list proprietary libraries, which are not available under a free software license? The answer is: Yes, we do want to also list proprietary libraries. We already are collecting the license information for all libraries, so this would be just another entry in the license field.

Inqlude is meant to be an open system. The goal is to have all libraries listed in one place, which are part of the Qt ecosystem and can be useful for application developers. So it's consequent to list all libraries there, independent of if their source code is available, or if there is a commercial model behind them. We will show the license data and add a separate section on the web site, so that people can easily find what they are looking for according to their preferences in terms of licenses.

I'm looking forward to the next two days of Hack Week. This is a fun project, and it looks like we can reach a state where it actually will be useful for quite a number of people.

Tuesday, October 8, 2013

An audacious goal for SUSE Hack Week 10

I have set myself an audacious goal for the tenth SUSE Hack Week: Create a complete collection of all Qt-based libraries which exist.


There are many places where you can find Qt-based libraries. Qt itself already comes with a number of modules. KDE has created a rich set of libraries with additional functionality on top of that, and you can find a lot of other third party libraries on sites like Gitorious, GitHub, Google Code, and more.

Now getting an overview and access to all the Qt library goodness, which is out there, is not particularly easy. To solve that we started Inqlude as a project to create an archive of all available Qt libraries back then at one of the Randa meetings. I worked on it some more at Hack Week 7, and continued to spend a little bit of time here and there. We have reached a state now, where it starts to become useful, and so I thought Hack Week 10 is a great opportunity to fill in the missing bits and pieces, and make it ready for prime time.


We have the web site and a documented format for library meta data. We also have tooling to process the meta data, e.g. for updating the data on new releases or to retrieve packages of libraries for installation. The web site also gets generated with these tools.

One thing which is lacking a bit, is the packaging of libraries, and the integration of the tools with the native package management systems on various platforms. With the help of the Open Build Service the packaging part should be solvable. For the integration on different platforms help of users of these platforms would be greatly appreciated. There is some support for openSUSE, but for other Linux flavors, or non-Linux systems, there is still some work to do.

The other thing is the coverage of the archive. It already has quite a list of libraries, but there are more out there, and I really would like to see it to be as complete as possible. All libraries, which reasonably can be considered useful to developers using Qt, should be on Inqlude. So I'm looking for third party Qt libraries now.

I'll be on the Qt Dev Days in Berlin the next two days, and hope that I can use this opportunity to get some more input and pointers to libraries, we haven't covered yet. If you are there as well and have hints, please talk to me. I'll also give a lightning talk about the current state of Inqlude, so you can learn about where we are first hand.

So this is my project for Hack Week 10. You'll find some more details and updates on the progress on the Hack Week project page. If you want to join the project, don't hesitate to add yourself there and contact me]. We'll use the inqlude mailing list to coordinate work as needed.

Monday, October 7, 2013

Looking for third party Qt libraries

We all know that Qt is great, but we also know that it can't possibly cover all use cases. Fortunately there are plenty of third party libraries based on Qt, which fill a lot of gaps, so you don't have to develop everything yourself.

Finding these third party Qt libraries can be a challenge, though. To address this we started a project to create a curated archive of all relevant Qt-based libraries some time ago (you may want to think of that as CPAN for Qt).

We have reached a state now, where the necessary infrastructure is there, and it's starting to become useful for production use. You can find the web site at inqlude.org.

To make this information more complete, I would like to give this a focused push now. My goal is to get all relevant Qt-based libraries listed by end of the week.

So I'm looking for 3rd party Qt libraries.

Are you releasing a Qt-based library? Do you know of libraries, which aren't listed yet?

If you do, please get in contact with me and let me know what's still missing. You can also create patches for the meta data, which the web site is based on. You'll find instructions on the web site.

If you want to get involved with the project you can also subscribe to our mailing list inqlude@kde.org.

Inqlude is meant to be open to allow everybody to participate on the same level. The infrastructure is free software. It's run by the KDE community, but we intend to cover the full Qt spectrum.

Let's make this a place, where Qt developers can easily find and get access to the full power of the Qt ecosystem.

If you have any comments or suggestions, don't hesitate to contact me.

Friday, June 28, 2013

SUSE Hack Week 9

The results are in. The winners of the awards for SUSE Hack Week 9 have been announced.

The award for the best overall project goes to the heroic effort to kill YCP. The team has made great progress and the plan is to see the results in milestone 4 of openSUSE 13.1. It will be the first SUSE distribution since ages, which will install without requiring YCP, the SUSE in-house developed programming language. This is quite an achievement. It ends an era and starts a new one.

Other awards went to the widely discussed team effort to create a light-weight deskop using KDE technology, to Tim's great performance as individual developer to get support for encrypted web sockets into QEMU's VNC implementation, or to the glorious openSUSE ARM team. There are more awards, and you can find the full goodness of all Hack Week projects on the Hack Week Wiki.


My own project was somewhat meta. Together with Henne I worked on a web app for managing the Hack Week projects. We weren't happy with the current set of tools, because they didn't provide enough support for discovering projects and fostering collaboration. So we set out to change that, took a deep grab into the magic chest of web technology, and wrote a new app. There is a demo and source code.


You can enter and maintain your projects, join and comment on projects of others, and browse projects to see what's going on. We also started to implement a recommendation engine, which hints you at projects, which match your interests. This gives a more structured environment than before, which hopefully makes it easier and more fun to collaborate on common interests. Some more details about what we did you can find on my Hack Week blog.

Our intention is to have this app ready for next Hack Week, so that we can use it for managing the projects then. If you want to help you can find the source code on GitHub.


Another fun project right before Hack Week was to set up the Hack Week web site. Cassio, André, Tom, Ken and me threw together some time and effort and came up with a shiny scrolling front page, complete with magic project lock, and a terminal mode.


And of course we had T-Shirts.


I'm looking forward to next Hack Week.

Wednesday, June 26, 2013

Konqi

I posted this on the kde-promo mailing list. But it's more fun with proper links, so I'm reposting it here.

Konqi is a part of the KDE family for a long time now. He has not only been part of our software and promotion activities, he has also made several real-life appearances on his own, or with his girlfriend Katie, and as a movie star. He has looked over the shoulders of many KDE developers and the plush version has been part of quite some kid's lifes, including mine.


Konqi has inspired artists, pastry cooks, and needlework. He also has been an excellent member of the family of free software mascots. And of course what would David be without his famous Konqi T-Shirt?

Konqi is part of our home as community, and while not everybody likes him the same, for many of us he is part of the identity of KDE. But he wasn't our first mascot, and he won't be our last one. The new rendition is cute, but still professional, and opening up a number of new interesting ways how to work with our mascot.

It will have to prove itself. I don't think it would be right to do a huge change to our mascot by a vote or a committee. But if there are people behind it, who give it a life, use it to give KDE promotion a fresh touch, make use of the opportunities it provides, it will grow and can become a worthy successor of our current Konqi. Then it will be part of the KDE family as well.

Tuesday, June 11, 2013

Experimenting with user interfaces for todo lists

When I presented Polka, my experiment to reframe the user interface for address books, some people suggested that it would be interesting to try something similar for todo lists. So I did try. The result is a small app called Bliss, because it makes you happy and gives you peace of mind.


I started with taking the concept from Polka to have freely arrangeable items on a canvas organized in groups. That works, but it had a flaw, because the basic element of todos is not the individual item, but a list.

Todos are much more dynamic than information about people. You create, remove, and rearrange them all the time. Context matters. One powerful effect of writing todos down is that you relieve your brain from having to constantly make sure you don't forget about them. This only works, if it's easy and quick enough to structure and arrange the todos according to your mental model. Lists are the natural structure here to keep priorities and order.

So basically a group became a list, where you can reorder items by dragging them around, either within the list or to other groups.


But in addition to this it's also quite useful to have multiple lists in one view. You can for example model a flow between things to do today, this week, and this month, where items in one list are replenished from the next one. Or you can have something like a personal Kanban with lists for things to do, being done, and done. Or you can use a scheme like in the Getting Things Done method. The combination of groups and lists is pretty powerful here.


Bliss keeps the complete history of what you did, so you can always look or go back without cluttering your views with done items. It animates all the transitions when moving items or navigating groups, so you don't lose context when items are rearranged or you change the view. Especially when dealing with such dynamic objects like todo items, animations really make sense, not as eye-candy, but as a way to support you in keeping track of what's happening. That said, they also make the app more fun to use.

The menus are done in the same way as in Polka, as semicircular context menus, which works nicely not only with the mouse, but also on a touch screen.


The code is in the KDE git as well as on GitHub. If you want to give it a try and play around with the UI you can get it from there. I'm happy about feedback.

The technology behind this experiment doesn't matter much. It's mostly reusing Polka code, a QGraphicsView based Qt GUI with an Kode-generated XML backend, which stores data in a git repository. To move forward it would be nice to redo the UI in QML and connect it to Akonadi. But the more interesting part it experimenting with the user interface right now.

Looking ahead it would also be interesting to rethink the UI of mails and calendars by moving beyond the limitations of the traditional widget based approach. This could make it possible to come up with user interfaces which are much more tailored to the natural mental model of people, and make full use of the opportunities you have by not being constrained to paper. There are tons of unexplored areas here.

I'm looking forward to more experimentation.

Monday, May 20, 2013

Don't sell free software cheap

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.

Sunday, April 21, 2013

How to deploy a Rails app to Heroku on openSUSE 12.3


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
Login to Heroku with
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.

Friday, April 19, 2013

How to run Rails with PostgreSQL on openSUSE 12.3

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.