i'm leaving on a jet plane

In around an hour I leave for the airport to attend Qt Developer Days in California, USA. It's been largely coordinated by the good people at ICS and KDAB and so far it seems they've done a remarkable job of it. ICS has even stepped in to offer travel support for some of the attendees, myself included, which is greatly appreciated.

I'll be presenting on a couple of topics at this Dev Days: open devices and writing full-blown applications with QML. The first topic will consist of a panel discussion as well as a BoF and I'll be doing my best to increase awareness of Plasma Active and what we've been building on top of Qt there. The presentation on complex applications written with QML is a bit more standard fare. In sharing some of the big lessons we've learned in the last two years when it comes to using QML seriously, my hope is that those in attendance can lower the learning curve, avoid common mistakes and think about new sets of best practices around QML.

Something that really excites me about QML is not only is it fast to work with and delivers great results, but it introduces a new paradigm into the Qt world while not introducing a lot of the high-level things required to actually write applications. This means the door is open for exploring new ways of doing things with an eye to better results. QML often gets set next to QWidget, but I don't think that's entirely accurate: QWidget is a tool that sits well and firmly within an existing language framework (i.e. C++) and provides a lot of pre-defined mechanism. There are a ton of useful UI bits written as QWidget subclasses and it is extremely well tested and proven by now, which gives it tremendous value, but QML allows us to break the molds that have tethered us to inflexible interfaces.

Breaking molds is not always a good thing, and I was healthily skeptical about what kind of results we'd get with QML. By taking it one step at a time, something Plasma's design allows us to do, we've found that we can replace QWidget based interfaces without our users noticing anything (other than it feels smoother :) as well as create sophisticated interfaces with easy which we would have truly struggled to deliver with QWidget. The new QML applications we've been writing for Plasma Active showcase this effectively, and I'll be expanding on these topics in my presentation at Dev Days.

Before leaving this morning, though, I updated the integration branch in plasma-mobile. This is something new we're trying out, following an ambition some of us have held for a few years now: a never frozen master branch. The idea is that all new development will happen in branches which are then folded into an integration when they are ready for it (according to the developer maintaining that branch). Testing will happen using the integration branch and when new features and bug fixes pass that testing (automated and manual) then the branches they are in will be merged into master when it is not in a release freeze. The goal is to keep master in a releasable state at all times, while also allowing developers to work on code on their own schedule. This decouples release engineering and development, allowing both to achieve their respective goals without getting in each other's way.

There are other projects that do this already, but it's a fairly new workflow within KDE and we're prototyping it, if you will, in the sandbox of plasma-mobile. We'll see how it works out over the next half year and then report back to the community what we've found. I'm optimistic that it will work well and that we will be able to recommend this to the wider KDE community, particularly for important shared components like Frameworks 5 where stability and development ease both need to be nurtured.

Read More

a relaxing friday

I took some time this evening to relax in a quiet, empty house by plonking away at the Plasma Active Alarms app UI. I'm still not 100% satisfied yet, but it's getting a lot closer.

Alarms plasmoid in Application form factor with touch components

Under the hood there are a lot of really interesting things going on. For instance, it's implemented as a Plasmoid that supports the Application form factor; the first Plasmoid to do so, in fact. What this means is that you can pop it on your desktop, in a panel or run it as an application and it adapts its UI appropriately. This is a new feature for 4.10 and I wonder what other Plasmoids may make similar leaps. Alarms also works very nicely in a "single column" form factor, smartphone style, when the horizontal space is constricted.

It uses Akonadi's spiffy KAlarm integration, so the alarm infrastructure was done for us by the KDE PIM team. This grants the Alarms app integration with all the other KDE PIM Stuff(tm) for free, too. Communication with Akonadi is done via a typical DataEngine and Service combo (org.kde.alarms). Due to this, without having to extend Plasma's C++ or QML API one bit, it was instantly and easily accessible in the QML as a model.

Still, there are caveats: The typography still sucks as we have not yet implemented the new guidelines in the components, something I want to see happen for Active 4. At least it is using all the "right" components so it can benefit as soon as the typography stuff slots into place. The plus icon looks dated by now (I'd guess it is one of the earlier Oxygen icons), and I'm not convinced with position of confirmation buttons in editor or the create entry ... the usual "must be perfect" itches.

But it's getting there ... at which point it'll be ready for features again such as more flexible repetition, selecting the audio file to play, etc. 

Read More

quicky update on window grouping

I posted a couple of blog entries the other week about how to show grouping in the task bar. The feedback was fantastic and we now have a "winner", at least for 4.10.

Many noted that knowing there is a group of windows just by glancing at the task bar is important to them. Very, very few find value in the little number, however. So putting it all together, in 4.10 a small arrow will be shown drawn over the window icon when there is a group, as is seen in many other dock apps. This preserves the most useful information while also limiting visual noise, creating a more compact layout in the window listing and finding consistency with other implementations out there in the wild.

As a bonus, the arrow is no longer the (in my opinion) ugly black thing that was specific to the window list but the standard arrow used throughout the rest of the Plasma workspace interface.

Thanks to everyone for your feedback!

Bonus time! ;) A curious little walk down memory lane: in the later 3.x releases of kicker (I forget if it  was 3.4 or not; but around that time, I believe) I implemented a new look for the tasks widget which was made configurable via the task applet's configuration dialog. The old look was kept as "classic" and the new look was named "elegant". When Plasma Desktop 4.0 was released, the tasks widget was rather different and looked a lot more like the "classic" style, but I kept to my commitment of deferring these things to the people doing the graphics, as long as they did not impact usability (which would trigger a discussion to find a consensus-base solution). With 4.10 we are now back to something much like the default "elegant" layout in later 3.x tasks applets. The grouping element is now nicer, but otherwise .. it's "elegant" from the old days. It's funny how sometimes things go full cycle like that. I'm just enjoying my nice, calm panel with fewer lines and borders.

Current master, which will eventually be released with Plasma Desktop 4.10

You may notice the Share Like Connect widget next to the activities button. That will not be a part of the default 4.10 setup (likely in 4.11, however), but you an already install it from the share-like-connect repository.

Read More

help test task grouping experiments

In my last blog entry I shared some experiments with the tasks widget I did this morning. A good number of people have offered feedback so far, which is great. It can be quite difficult to guess at the usability impact of something like this with just screenshots, so let's take it to the next level, shall we?


I have uploaded a tarball of a modified tasks widget here and I'd love for you to try it out for at least a full day.

You will need cmake, a C++ compiler and the kdelibs and kde-workspace headers installed.  On OpenSuse, the kde-workspace headers are in the kdebase4-workspace-devel package, for instance, so a simple "zypper install cmake kdebase4-workspace-devel" should hopefully get you most of the way there.

Once you have downloaded the tarball, extract it to somewhere on disk and then create a build directory inside of the resulting directory. From in the build directory do something like: "cmake ../ -DCMAKE_INSTALL_PREFIX=`kde4-config --prefix`".

If all goes smoothly you can do a `make && sudo make install && kbuildsycoca4` type thing and you'll now have a new plasmoid called "Tasks Experiment" in the UI and org.kde.tasksexp behind the scenes. It won't trample on your existing tasks plasmoid or anything.

From there, remove the tasks widget from your panel and in its place put a tasksexp widget. You can even do this from a command line with something like this:

> kquitapp plasma-desktop
> perl -pi -e "s,plugin=tasks,plugin=org.kde.tasksexp,g" `kde4-config --localprefix`/share/config/plasma-desktop-appletsrc
> plasma-desktop

Voila.

You can also try it with the "stack icons" grouping by opening up the abstracttaskitem.cpp file and removing the two /s on line 71 so that GROUP_INDICATOR is defined. Then go back into the build directory and do the make / make install dance again, kquitapp plasma-desktop and start it up again.

After a day or two of using it, let me know how it works, or does not work as the case may be, for you.

 

Read More

mark grouped windows as such or not?

In the default tasks widget (the one that shows your currently open windows) if there is more than one window grouped together it shows an arrow and the number of windows in that group. This results in a panel looking something like this:

Tasks widget with group status information

Great, so I can see I have two konsoles and three kontact windows open. However, today I challenged myself to defend why that information is there. Is it actually useful? Does it matter if there are 2 or 3 windows in the group? Is it important to be able to visually identify it as a group?

With or without this additional information, the number of clicks to get to a window in a group is the same. Click once on the group, and then again in the resulting popup. If compositing is active, you can also just hover the group and then click on a window thumbnail.

I could not think of a single time when the extra visual information of the arrow and number ever provided value to me, and I struggled to come up with a use case where it might. So I patched out the group status information just to see what it looks like and to see if it would negatively impact how it works. It took all of probably two minutes to do and I've been using the tasks widget since without grouping status information, as can be seen in the shot below:

Tasks widget without group status information

There is more room now for window titles which is nice, and there is less information being presented resulting in a more elegant look.

Visual simplicity, however, should usually not trump utility, however, so I'm trying to come up with uses for the group status information. Just because I can't think of one off the top of my head does not mean that a use case does not exist. So I thought I would ask you! Do you find this group status information useful? If so, why? If not, would you prefer it not to be there? Leave your answer in the comments section below!

Even if you don't have input to share, you at least get a glimpse into the sort of banal questions we get to ponder when working on Plasma. Not everything is about exciting shiny new toys after all. :)

Update: Decided to try another possibility: show grouping by painting the icon twice, once full color and a second time faded. Keeps the visibility of "this is a group" without taking up more space and with less visual noise. Not convinced by this, but was something that occurred to me as a possibility. :)

Using a visual "stacking" of the icon to denote a group.

p.s. Please ignore the misalignment of the system tray in the screenshots. It's a known bug in the QML UI that is new for 4.10. It will be fixed before release.

p.p.s. Please also ignore that the task icons are a different size than the other icons on the panel. I'm considering possible improvements for that too as all icons being the same consistent size, at least when there is just one row in the tasks widget, would be rather spiffy.

p.p.p.s. I am not interested in suggestions to replace the tasks plasmoid with some other plasmoid in the default layout. That is a separate discussion, and I'd like to focus on this one specific issue here.

Read More

the sun is a billion little spotlights

The sun is a seething sphere of plasma consuming approximately 600 000 000 tons of hydrogen per second,  lighting our solar system with its raging burn.  Even at 150 000 000 kilometers away from the sun, our little blue planet receives 1 800 000 0000 000 000 000 Joules of energy from it every second, or over 10 000 times the energy humans consume. This immense amount of energy, spread across the Earth, allows all the weather, all the life and so much of the beauty we see around us.

You can focus the energy of a square meter of sunlight on earth with a Fresnel lens and this will provide over 1000 Watts of energy in a very small space. This is likely to hurt, or even extinguish, any living thing that finds itself in the way of this energy. Which is why it is pretty handy that the energy from the sun does not simply come out in a single beam of light, striking the earth in one place. Even with a handful of such sun powered spotlights, there would be a few areas with hellishly intense levels of energy while the rest of our Earth (assuming it would exist at all) would lay cold and desolate.

This is why I like to think of the sun as a billion little spotlights, each shining on some patch of our earth. Every plant, every animal big and small, gets an opportunity to have a little light shone upon then. Enough to power life, but also not so much that it is destroyed. Perhaps more fancifully we could think of daylight as the combined effect of all those spotlights. :)

The free software community (you knew it was going there, right? ;) is a seething community of millions of humans generating amazing amounts of creative work. This is an amazing source of attention energy with people looking for answers and answering questions and creating new questions for people to find answers to. This energy tends to get hyper-focused at times, robbing some areas of our little planet of code of needed sunlight and bathing others in cancer-causing dosages of it. I think we can be like the sun and spread it out a bit more. We can cast a million smaller spotlights, and while that may make the light a little less exciting, the results will be a rather more lush environment.


Armageddon levels of energy may be exciting, but I'd rather spend my days in a field full of flowers.

On Google+ today I read this from John Layt:

Great weekend in Brno at the Linux Color Management Hackfest, a mix of Oyranos, colord, KDE, Gnome, openSuse, Red Hat, and Ubuntu people all just getting on with figuring out how to get things done.  There wasn't even a single heated argument, so don't expect it to hit the headlines any time soon :-)  We really need more of these type of events to build communities around the common desktop infrastructure.  Now to try organise and write-up my thoughts for posting to kde-core-devel and qt-development, could be an epic!

Awesome! But ... "there wasn't even a single heated argument, so don't expect it to hit the headlines any time soon"? Really? Can any of us be proud that this is where we are, that unless arguments surpass a certain (arbitrary) threshold of controversy we don't expect it to get attention? Is this not the best way to breed bad behavior and rob the spirits of those who put in honest efforts?

So let's shine a million spotlights on the things we're achieving, like this color management hackfest. Let's take a low-powered moment to celebrate the working-togetherness and positive results of it. Let's see that on the front page of Slashdot; let's read about it (and a dozen other daily events) on our blog planets. We'll have less time and energy left over to fanboi obsessively over other things that are, relatively, less consequential. And that's OK. It would be a more complex story to follow, just as it is harder to pick out an individual plant in a dense youthful forest, but it would be thick with life.

In a technology industry where the dominant pattern right now is to hyperfocus on a few products from a few companies driven by a few myth-level superstar heroes (who, like all myths, are mostly not real), this would be an amazing source of advantage for Free software in the same way as the sun's light being spread across the whole of our planet is to biological life.

It may seem that there is a fly in the ointment here: this may not scale since people who wish to just sample what's going on, rather than devote their life to keeping up with Free software, only want to hear about the "big" events and high-level summaries. Fortunately for us, we have news organs such as Linux Weekly News that can do just that. Interestingly, I have noticed a lack of obsessive hyperfocus dysfunction in such "we summarize the news for you" outlets, particularly when the community being covered is diverse and doesn't hyperfocus. In the grass-roots Free software community, we need to set the (plurality of) topics in the community rather than allow ourselves to pulled about by the gravity of these "summary level" efforts. We need to be (positive) sources rather than reactive agents.

So let me put my spotlight where my mouth is: To everyone who was at the Linux Color Management Hackfest: you are my inspiration for today. I hope you had an awesome time and I can't wait to use (and tinker with, of course ;) the results when they find their way into a nearby source code repo. :)

Read More

cults of personality redux

In a recent blog post, I slammed cults of personality in Free software communities. Some noted in the comments that this was not the only challenge we faced, and I completely agree. On the one hand, it's a bit of an odd observation to make: of course all complex results have complex sets of causal factors. Entire volumes have been written about this aspect of complex challenges, and a thread I've noticed in a number of pieces I've read is that the shear number of causal factors makes it hard for people to untangle and overcome the challenges presented. It's like we become distracted by too many topics and forget that you eat an elephant one bite at a time and not all at once; that it is OK to examine and address issues in a piecemeal fashion.

Others noted that there are some good affects that come from these cults of personality. This is also true. But it's sort of like saying, "Since I put $100 in the bank today, I will have $100 to spend." That may be true, but if you already spent $500 using your credit card .. no, you don't have $100 to spend. You owe $400. This is simple math that most people get intuitively, but when we apply it to systems analysis it often gets missed. Most things people do have some advantage (locally, individually, in the here-and-now, etc), and that is usually how they get entrenched in the first place. Full accounting, which means looking at the broad spectrum of results, is required to come to a full and proper sum, however. Some benefits are not good enough when there are large amounts of documented negatives.

Then there were people who said that they agreed with Linus. This is accurate, also. However, when looking at systems issues (which is what a cult of personality is: an attribute of a community, which is a system of social actors, in this case humans) the individual interaction is not the whole picture. I was certainly not asking if people agree with Linus, or if Linus is correct in any given statement. The issue is whether or not it is healthy to continuously and universally elevate a specific individual's opinions.

In case the answer is not clear to you, consider where this is actually practiced (dictatorial government, religion and pop culture media, to give three examples) and where it is not (the scientific method, participatory democracies) and then reflect on the empirical results each produces. One set puts humans Mars and works to ensure human rights are respected; the others give us things like tabloid magazines, inspires violent radicals and robs people of freedom in the name of expediency for the few.

I was really not interested in issues of personal agreement, but systemic affect. This is what I meant when I wrote, "I don't care what Linus says." I might agree with him, and yet my issue with putting that opinion on the front page of every F/OSS news site still stands.

Finally, some noted that there was perhaps a cult of personality around me and so I shouldn't throw stones, living as I am in a glass house. I truly hope no such thing actually exists, but if it did I would actively discourage it. I see myself as encouraging critical thought, attempting to inspire others to achieve more and organizing efforts where beneficial. In doing so, people may end up paying more attention to what I say than the average Free software contributor, but it is not (or so I hope) because of a blind belief in an abstract "Aaron" but due to the individual thoughts and experiences I share as I share them. I also hope that my attempts to spread awareness of the work of others, to highlight positive issues rather than only hipster-rant about negatives, etc. has a positive effect beyond my own standing in the community.

I see others in the Free software world doing this same kind of work as well, often better than I do it in fact, and that set of philosophers, organizers, leaders and generally motivated individuals are whom we ought to pay attention to in the areas where their efforts are applied. We would benefit by focusing some of the attention we lay on F/OSS "super stars" on those people.

That, really, was the entire plot point of that "cult of personality" blog post. :)

Ok, enough of that .. let's move on. (continued ...)

Read More

plasma sdk accreting

If you have used plasmoidviewer, plasamengineexplorer or plasmawallpaperviewer from past releases of KDE Workspaces while developing Plasma components, you may be surprised to find them gone in the upcoming 4.10 release.

Well, they aren't actually gone: they have been moved to the plasmate git repository. This is where the streamlined Plasma add-ons creator has lived in nearly perpetual alpha/beta for longer than I care to admit. It's finally in the release review process (aka "kdereview") and we decided to take this time to remove all the bits that are only interesting to developers from kde-workspace and put them in one place.

 This also opens the way for us to share more code between these developer tools, such as the Plasmoid previewing that is in both plasmoidviewer (obviously :) and Plasmate.

If you are concerned that you use plasmoidviewer to run individual Plasmoids in a window, do not despair! You ought to be using plasma-windowed which does a much better job of this and which has been available in kde-workspace for quite a few releases by now.

So now if you clone the kde:plasmate repository you will find all these developer tools in one convenient place. Enjoy :)

Read More

ending the cults of personality in free software

Free software has a history of creating and supporting cults of personality. Since it is a widespread human phenomenon, it is easy to understand how this happens. It is, however, unhelpful and destructive and we really ought to actively discourage it, starting by putting aside the current cults.

The most recent, though certainly not the only example, of this retrograde behavior was seen when Linus Torvalds started posting on Google+ about his recent sampling of various Free software desktop options. This made the rounds on various blogs, Slashdot, Linux Today, etc. Why do we care what Linus uses? Simply put: he's a super star in F/OSS and people hang on his every word as a result as if he's an oracle of all things technology. Spoiler alert: he's not.

His opinion on desktop software is as meaningful as his opinions on rocket ships, film production, oil recovery techniques, sociology, religious history, automobile engineering or any of the other topics he has no meaningful expertise in. Everyone will hold an opinion on things they use, such as cars or ships, and things they simply come into contact with, such as film and religion. Sharing our viewpoints is great and a necessary part of democratic discourse which can move societies along their evolutionary path. So opinions have value and can be hugely beneficial when mixed together with hundreds, thousands or even millions of other samples. The trick, however, is not letting those whose opinions are of no great value in terms of being based on greater understanding or access to relevant data become more important than other opinions in those discussions.

Linus is as likely to be "wrong" about desktop Linux as most others who use the desktop. I used quotation marks because he isn't really wrong at all: whatever his viewpoint de jour is reflects his viewpoint very clearly and may even be extrapolated to other people with similar needs and backgrounds. This should not be surprising. It's like saying Linus is as likely to be wrong about rocket ships as anyone else who is into rocket ships but not involved in their design and manufacture. Perhaps more so, even, if Linus isn't a big space enthusiast but only an occasional article reader and watcher of things NASA puts out press releases on.

When I first saw others commenting about his comments on Google+ about trying KDE Plasma, I shared the above sentiment, but in a more compact form. I don't care what Linus uses, at least not as an isolated data point: it is not useful information for one simple reason: it does not help us create the software the world needs.

Let's step to the side and consider this from a different angle: Imagine that someone made Linus' perfect desktop environment. Something that satisfied him entirely and which he could happily talk about whenever he felt like it. Would that environment be interesting and useful for the general public, or would it be something great for kernel developers and grumpy-heads like Linus? It could go either way, really, because (once again) the fact that Linus liked it would not be useful information when held in isolation by itself.

We could pick any other single individual on the planet who lacks the same amount of relevant experience and say the same thing. This is not a bash on Linus, it's an observation of something that Free software world does very poorly. It is not Linus' fault we pay more attention to him on such topics than we ought to; it's us who decide to pay attention to Linus on such topics. We can also decide not to. Even better, we could focus on amalgamations of well formed data sets and pay attention to those instead.

So why, then, do we pay so much attention and care at all what Linus says or thinks on these matters? There are very human reasons for why we do this, which the social scientists in the crowd can probably speak to rather better than I can, so that's a largely rhetorical question. I believe it is undeniable, however, that we risk the direction of Free software by building such cults of personality. It create incentives to acquiesce to what amounts to low-value personal opinion which leads to a meandering pattern of non-progress.

Of course, it goes even further than that. These cults of personality encourage others to mimic people like Linus when it comes to things like communication style. Due to the "we mimic which we admire" tendency in human, holding Linus aloft encourages people to adopt incorrigible asshat communication patterns online. Linus is not a role model for anything other than running very successful kernel (and similar) projects, yet he gets emulated by people who mistake the secret of his success with his communication style.

The cult of Linus is not the only center of a personality cult in Free software, to be certain. This episode was simply a good opportunity to say something about it. I could just as easily write a blog entry about the problems other cults of personality have caused in Free software. My years in the community have "blessed" me with a great big bag of personal experiences related to just about every single out-sized personality in Free software.

... which is the "big lesson" here: nobody is a messiah and we are all equally frail and imperfect. In more positive words: we are all equally infallible and perfect. So where can we derive leadership from, if not from luminescent personalities?

I don't believe Free software needs, or even benefits from, global leadership, anymore than the world needs dictatorships or a single global government. What Free software needs is local leadership, and those leaders need to have their influence limited (by a healthy lack of deification, among other things) in order create an environment in which it is valuable (and more acceptable) to reach out to others across domains.

Without this, we drift ineffectually. Free software was not able to truly take off on consumer devices until a corporate dictator stepped in, basically ignored everyone else, and pushed out Android. That in turn has become a primary source of GPL violations in today's world (I just found another one today, this time in a tablet being offered for sale by a very nice and reputable Free software supporting computer retailer) and is not an ecosystem with equal participation or open governance as hallmarks. We needed Android because we couldn't do it ourselves, but Android is also a huge weakness for Free software efforts and falls well short of what is realistically possible. We can't complain too loudly though, because we couldn't get our shit together to produce better results sooner.

We're still waiting for this savior on the desktop side. Some thought it would be Ubuntu, but what we got from Ubuntu, largely due to a "self appointed dictator for life" approach, is a fork of one of the major desktop environments and its community with a unhelpful sideshow of nearly endless backbiting between various Linux distributions, kernel developers and others with Canonical. All of this happened for understandable reasons, none of it was done without internally consistent logic, and yet it has not furthered anyone's ultimate goals for Free software success.

I don't know about you, but I am sick and tired of Free software being inefficient and self-destructive due to internal schism.

Ah, but we do have a positive example where Free software has done very well: the server and super computing. Why has Free software, driven by the open source development model, shone so brightly here? When we take a deep look at its history we may note the relative lack of personality cults and the amount of emphasis on data that matters (something that is easier to accomplish when one can use performance benchmarks or compliance suites as respected and reliable metrics). Certainly there are people who are respected, admired and influential in server-side Free software, but there has been a distinct lack of personality cult and a huge number of of cooperative (even in competition), technology-centric efforts. Samba springs to mind immediately for me with the likes of Jeremey Allison and John Terpstra, two people I highly respect but who don't have that "cult of personality" aura.

It's not all roses on the server side all the time, of course, and as a counter-example to Samba I'd probably point to MySQL and its travails over the years (from early non-Free software status, to odd GPL interpretations to corporate take over), which I believe directly correlates to its centralized control by charismatic leadership coupled with project fanboyism. You know, just like we see with desktop Linux.

To those who may agree but reply with "that's just how people work, not much we can do about it": well, I accept your POV and humbly disagree. We may not be able to change the world at large (at least, not over night), but we can positively affect the parts of the world we create ourselves. We create Free software together, and therefore we can create it in the image we want it to be.

As a participant co-creating this world, I have an impact on how it works and the culture that surrounds it .. as do you. We are not completely powerless to ourselves; we can make wise choices if we choose to. The progress of social justice in human history has shown that we are not slaves to our human foibles, though it can take time and effort to emancipate ourselves.

We can make the decision to free ourselves from cults of personality by taking our own advice: build decentralized structures of responsibility, influence and attention that reward things like cooperative effort. This will allow us to bring our efforts together into one combined and massive bonfire rather than thousand tiny embers fighting for fuel and oxygen such that they twinkle in but then almost inevitably back out again.

We need to realize that the behaviors that arise from our current culture do not further the goal we all share together of Free software success. If that is truly what we want, then we need to alter that which retards our progress towards it. We need to value Free software progress more than we value the reward of mutual fanboyism.

Put simply: if we want open client-side software to thrive we need to engage in a conscious improvement of the Free software culture and, just as importantly, leave behind those who choose not to. I won't try to fool anyone: this will take years to accomplish ... but we can start now.

Go ahead and say: "I don't care what Linus Torvalds uses on his computer." See how easy it can be? :)

Read More

one code base, multiple form factors

Yesterday we pushed a small but significant clean-up to a feature set we've been working on for a couple of years now which is perhaps one of the more interesting things we're doing in Plasma: the idea of "one code base, multiple form factors."

The idea is that whether your application is running as a widget on the desktop, docked in a panel, running full screen as part of a mediacenter, running in a touch based environment or as a regular ol' app-in-a-window, much of the code can be shared. We often put the non-graphical bits into shared libraries, and traditional we've built multiple front ends that are optimized for different form factors and input methods which use these libraries.

What would be even nicer would be, at least where possible, to raise the level of code sharing a bit and make it possible to also have the user interface adapt. Instead of having multiple user interfaces, you'd write one and it would be adapted depending on where it is running at the time.

One piece of the puzzle has been to communicate to the application this form factor information. In Plasma we let a component know when it is in horizontally or vertically constrainted presentation (usually a panel), when it has full run of a 2D surface, when it is full screen, etc. That's just the start, however.

For apps written with Qt Quick using a mix of QML, Javascript and perhaps some C++ bits behind the scenes, we ship the interface in a Package. Inside that package is a contents directory where all the individual QML, Javascript, image and other data files reside. There's also an optional "platformcontents" directory, and beneath that you can put platform customizations.

For example, if the interface should be laid out differently depending on whether it is on a tablet or a desktop, you can have a platformcontents/tablet/ directory. If you want to provide customizations for touch, platformcontents/touch/. Any files that are requested (be it QML, JS, images or whatever) that exist in those directories will be used instead of the version in contents/ when on that platform. In fact, on a tablet, anything in platformcontents/tablet will supersede platformcontents/touch.

Furthermore, the form factor also controls the QML components that are used to build the interface. For example, on touch we use thin scrollbars that fade out when not in use, as is typical on mobile devices, while on the desktop we use a much more traditional (and easier to use with a mouse) always-visible scrollbar.

How does this look in QML? Very boringly, it's transparent:

     import "plasmapackage:/code/Foo.js" as Foo

Will grab the correct Foo.js depending on the current form factor. Same for SVGs or other images requested or other QML files that are loaded.

This is controlled either by putting an the kdeglobals configuration file like this:

     [General]

     runtimePlatform=tablet,touch

Or by setting the PLASMA_PLATFORM environment variable:

    PLASMA_PLATFORM=desktop myApp

    export PLASMA_PLATFORM=tablet:touch

There is no limit as to how many form factors can be defined in the list, and it goes from most specific to least specific, finished up by the input style. The last entry controls which set of default components are used, and the other entries are used to define where in Packages to search for form factor specifics.

This actually works in Plasma Workspaces 4.9, but was a little harder to configure and get the expected results. Now there is just the one setting in either the configuration file or environment variable and any application can get at this information if needed via libkdeclarative. 

From here, we want to make it easier to switch to full window presentation (aka "traditional desktop app style"), continue to improve the individual QML components for different targets and hopefully also find a way to hook directly into QML's import statements to make this feature absolutely ubiquitous. We're already miles ahead of most of the competition here, though, and we know it works because, even if you didn't notice it, you've been using a system with these features for a while now. And if the user doesn't notice it, then we've succeeded, as that's the entire point. :)

More documentation here.

Read More

onwards to Four

Not being the sort who rest much, we're already at work on Plasma Active Four. We met up on irc to firm up our plans. You can read the minutes here, thanks to Thomas who took the time to summarize the multi-hour session.

We are moving to a devel workflow in which we aim to have an "always-releasable" master branch. All development will happen in branches, something we essentially do already, but we will now also have an integration branch so we can bring the various branches together for testing before merging them when ready, branch by branch, into master. We have been working towards for some time, adjusting our habits one step at a time. This will only cover the plasma-mobile, share-like-connect and plasma-active-maliit repositories for now, but my hope is that as Frameworks 5 arrives we'll be able to broaden this to the bigger shared repositories such as kde-workspace.

We also set a release date target of March 26th, with betas and release candidates starting one month prior to that. So what do we plan on accomplishing between now and then?

Most of the core team's efforts are going to be focused on improving what was new in Plasma Active Three. We'll be focusing on one component at a time for review so we can document what needs improving, prioritize those items and then work on implementing the improvements in a time-boxed devel cycle, or sprint.  We are starting with Files for the first three week sprint, and then will move on to Share Like Connect. Not all sprints will be the same length. Some will be only one or two weeks, all depending on how much needs doing and how much time we have.

One of the Maliit input system developers joined us at the meeting as well, which was great as we have a lot of work to do on the on-screen keyboard still. We are very much looking forward to the improvements that Maliit 1.0 will bring, but that won't be Plasma Active Four material. We will be working on bringing multiple layouts and improving some of the current ergonomics. Already a few annoyances and bugs have been fixed, and we recently merged in some changes to the default layout.

There are also some new feature sets in the pipeline for Plasma Active Four. Work on syncing is already well on its way with ownCloud and akonadi integration (Sebas will probably blog more about this later) and screen rotation support (thanks to JP). More and more, though, we'll be looking to others to work on new applications and feature sets such as these.

... and now for something completely different: screenshot porn of a few things already in master for the Plasma Active Four release.

Read More

KDE Manifesto in action: bodega server

I wrote the other day about why the KDE Manifesto is important for the KDE community. Today I'd like to show how it can be used in practice with a real-world case study: the bodega server. Coherent Theory has been working on this content distribution system for a while and it does things rather differently in a variety of ways including:

• Free software licensed :)
• multiple owner-defined store fronts to the same (or different) bodies of hosted content thanks to a tag-based metadata system
• able to federate external content (a feature set I expect will evolve significantly over time)
• good for books, music, services, artwork, etc. as well as for applications; essentially any content or artifact that can be delivered over the network works just fine (which is why we don't call it an "app store")
• built-in purchasing system using a points mechanism which can be tied to monetary purchases (swipe integration is included), gift cards or pretty much any other system you can think of (e.g. in a school environment students could earn points through their performance in class)

The implications of such a system being Free software are potentially significant. Both server and client code currently reside in KDE's review repository so that, if all goes well, we can move it into Extragear in two weeks time.

The client side currently consists of a C++ library (dependencies: QtCore, QtNetwork and QJSON), plugins to handle installation of downloaded assets (some of which use KDE technologies like Nepomuk) and a UI written in QML that uses Plasma Components and a variety of KDE libraries. It's easy to understand why the bodega-client repository can be called a KDE Project: it uses lots of KDE libraries,  integrates rather beautifully with the Plasma workspaces and the development community is well integrated with the larger KDE community.

But what about the server? It has no user interface; it doesn't use any KDE libraries, or even Qt for that matter. Instead it is built with node.js, PostgreSQL and Redis, none of which are particularly "KDE". Does this server-side code, in its own self-contained repository, make a good candidate to be a KDE Project?

We can start by looking at its relevance to KDE's goals. The bodega server was designed with devices running a KDE workspace, such as Plasma Active, in mind. Indeed, this is what powers the Add Ons application in Plasma Active 3. Since it is general purpose software, it can be used for all sorts of things, but integration with KDE software has been the development team's primary motivation. So the focus seems relevant to KDE, but is that enough to consider it for inclusion as a KDE Project?

The KDE Manifesto helps us here as we can use it to check if the foundational principles of KDE are found in this project. These principles are: Open Governance, Free Software, Inclusivity, Innovation, Common Ownership and End-user Focus. Without going into point-by-point details, bodega-server ticks all those boxes.

What about the commitments? There is no Contributor License Agreement to sign; the repository is open so all KDE contributor accounts are able to participate; the project already uses KDE infrastructure; trademarks and copyrights are in order; established KDE community principles are being followed (such as going through kdereview), etc.

With the Manifesto in hand, we can see that it is a reasonable candidate for becoming a KDE Project because it matches the focus, principles and the goals of KDE. Prior to the Manifesto, it was a lot harder to identify if something like Bodega ought to belong under the KDE umbrella. Other server-side projects struggled with this exact issue in the past, at times with rather unfortunate consequences.

Now it is quite straight-forward; we simply have to ask, "Does it push forward KDE's technical agenda, and does it meet KDE's documented principles and commitments?"

Read More

KDE Manifesto

Kevin Ottens recently blogged about the shiny new KDE Manifesto. He does a great job of explaining the motivations behind such a document. As he noted, I gave a keynote at Akademy six years ago on this very topic. Evidently it's something that has been on my mind for a while, and the reason has to do with sustainability of the KDE community.

By the time I wrote that keynote, KDE already had very clear social principles, agreements and mechanisms. They are reflected in the new Manifesto, so there is in one sense nothing really new there. What is new is that those principles are being stated openly and clearly. Not everyone felt they needed to be, and so I'd like to address the reasons why this is such an important step for KDE.

KDE as a community, a technology creator and the keeper of many assets with value (ranging from KDE e.V.'s bank account, IT infrastructure, trademarks, reputation, etc.) is something that many people and organizations want to be a part of. This is a sign of success that was built up over the 15+ years of history of KDE. As new projects and new people come together under the big tent of KDE, we are faced with three key tasks:

1. Enabling external self-identification: Making it possible for those who are not yet affiliated with KDE to know whether they ought to be and what that would mean. This helps KDE remain relevant and full of energy. We've seen this happen with projects like Simon, Kdenlive and Necessitas.
2. Enabling internal identification: As KDE has grown, it has become populated with more and more projects and products that do not fall cleanly into the original technical scope of "targets the desktop paradigm and uses Qt and KDE libraries fully." We even have multiple applications focusing on the same category or area of interest. Which of these applications is a part of the KDE system?
3. Passing these capabilities on to those who come after us.

The Manifesto is an important tool in accomplishing the above. It helps avoid dissension due to a lack of agreed upon definitions. Interestingly, we collectively already knew what makes something KDE or not, what benefits come with that and what the commitments are ... we just hadn't put it down in writing yet. That act takes our collective wisdom and makes it available to all individuals at all times.

Prior to the Manifesto, when "grey area" issues arose, (well-intentioned) people would too often disagree over things they agreed on just days, even hours, before. Prior clear understanding of what it was to be a part of KDE would dissolve when we looked at it too hard or with too much on the line. That's just how people tend to work in group situations when it becomes necessary to turn implicit knowledge into explicit agreement, especially as stress is added. (Unresolved questions involving a common good is a source of stress in a group.)

Prior to the Manifesto, when KDE members would leave for one reason or another (the most common reason probably being lack of time due to changes in personal life), they would take their social knowledge with them. New generations of KDE members often were left to figure the pre-existing structures on their own, such as what a maintainer is in KDE. Now, we have a way to easily point new members to what our commitments are and what benefits come with them. This will help create continuity in the long term.

I'd like to stress that these are not theoretical problems. Well, they were six years ago when I gave that keynote: things were sailing along pretty smoothly then. However, upon examination, it was clear the the particular growth path KDE was on meant that this would not last without us taking action. The Manifesto was not the only thing needed, and we worked on other parts of the solution over the years, but the Manifesto is a keystone artifact. And yes, it took six years of effort. Turning an entity as big as KDE is like turning a large boat at sea: you can't do it quickly. This is important to keep in mind for future efforts ... though that is a topic for another blog entry entirely perhaps.

It is quite important for us to remember that the KDE Manifesto  is a living document, just as KDE itself is a living and evolving community. The Manifesto will see revision over time as we come to understand it better ourselves and improve our ability to communicate it clearly. It will be an iterative process which will see the Manifesto evolve with time. So having come this far down the road on a journey we should all be very proud of, we aren't finished.

And we never will be: maintaining a community's health is a journey, not a destination.

I'd like to thank Kevin Ottens and those who helped in the process of drafting and vetting the KDE Manifesto. It was a huge effort, both in terms of energy put into it and importance, and that deserves our appreciation.

Read More

Plasma Active Three

After several months of concerted team work, we have put the final wrapping on the next major release of Plasma Active. The last two weeks were spent testing on both ARM- and Intel-based devices to identify and fix show-stopper defects. It was time well spent, resulting in a polished release that shines as a successor to Plasma Active Two.

In keeping with our straight-forward naming scheme, this release is simply known as “Three”.

... or download the video in ogg format.

You can go read the official release announcement and news over on The Dot, but what follows is my tl;dr version of what we've been up to in making Plasma Active Three a reality.

A (Probably Not So) Quick Recap

Before I start writing about what's new in Three, let's recap what Plasma Active is in the first place. Plasma Active is a user experience for mobile and media devices built around the core design concepts of "simple beauty," or elegance, and something we call Activities.

You may have seen the word “Activities” in other user interfaces recently, but the word tends to get used as a rather hollow place-holder to mean “something that lets you do something.” Ye-e-e-ah. By contrast, Plasma has a concrete, useful definition for the term which Plasma Active's UI revolves around: activities are a holistic representation of your interests and topics of focus. What does that actually mean?

It means you communicate to the device (explicitly and implicitly) what you are interested in, experiencing and doing with that device; the device responds by keeping everything related to those various interests together for you. This allows the device to keep up as you move from one interest or topic to another.

A Plasma Active device can be your travel planning system one moment, your school textbook the next, your social media portal the next … all depending on what you are wanting to pay attention to right now. This verb-centric concept focuses on your information and the relationships within.

This design philosophy allows us to do several really cool things:

1. Plasma Active can filter the information on your device to match what you are focusing on. This lets you put large amounts of information on the device without it becoming a data swamp that is difficult to move around in.
2. The file system almost completely hidden. The focus is on meaning and relationships rather than hierarchical filing systems. (If you do need to root (excuse the pun) around in the file system, we do include a terminal application as well: the handy-dandy konsole.)
3. Thirdly, it allows us to expose global concepts such as linking, sharing and tagging in a meaningful and easy-to-use way. I have found most systems that use concepts like tagging to require a large (and consistent) investment to get any real pay-off, while in Plasma Active I hardly even notice I'm doing anything.

As a result, we can deliver devices that work closer to the way our minds do; devices that are able to switch between concepts quickly, with a focus on one at any given time. The (often rather convincing) illusion of conscious multi-tasking generally arises from our ability to topic-flip efficiently; humans tend to be pretty poor true multi-taskers, however. Plasma Active is designed for how we're designed, and the benefits of this show up clearly when we put Plasma Active into the hands of people to use.

Around this core design we've pulled together a growing body of touch-optimized functionality based on KDE applications and frameworks so that a Plasma Active device is useful from the moment you turn it on: finding and reading books, opening up office documents, exploring your files, full groupware and a collection of fun games are just three things that compliment the typical applications of web browser. You don't need to open an app store or package manager: this is all there by default.

Best of all, it is all extremely easily to customize, change and advance. Developed completely in the open, sporting a very "normal" Linux userspace with no lock-down or lock-in and no royalties lurking in the background, Plasma Active is the perfect choice for building device experiences with. While other systems seem to go to great pains to weld the seams shut as tightly as possible, making it hard or even useless for bespoke applications, Plasma Active is built to be flexible, adaptable and accommodating of design requirements, whatever they might be.

What to Love About Plasma Active Three

Ok, tl;dr already, right? Let's get into what's up with this new release. After the release of Plasma Active Two, we decided to focus on a number of key areas, starting with the core set of applications. We began by building a file manager that reflects the Plasma Active design philosophy of “actively elegant”.

Managing files elegantly with Plasma Active Three's Files app

Unlike traditional file managers, Files doesn't directly expose the file system. We see that as an implementation detail like “which kernel drivers are loaded.” Yes, it's needed for the device to function, but the person using the device shouldn't have to care. Instead, Files promotes meaning and content. On starting Files, you select what you wish to view such as documents, images, music, videos, etc.. There are even stand-alone launchers for things like “Books” and “Images” which actually just launch Files in a content-optimized presentation. You may not even know you are looking at a file manager ... and if so we've succeeded.

Files lets you browse your information using a timeline, tags (including creating and removing tags with simple touch interaction) as well by activity. Oh, and it has a built-in search that doesn't only hit file names but also metadata and content.

The next thing we wanted was a way for people to add “stuff” to their devices easily. We had three primary objectives for this one: freedom, elegance and generality. The result is Add Ons, a system that can install books, wallpapers, applications, widgets .. actually anything that is packaged in a manner the system understands.

The content is accessed using a simple JSON interface. The server behind this is provided under a Free software license, and all the client and server side code is available from KDE's repositories. So not only are we able to provide a way to get at (e.g.) thousands of books really easily, we've also made it so that anyone who wishes could self-host their own system (or even have us host it for them). We believe this opens a whole new arena of possibilities for the use of devices in education, tourism, manufacturing, project-based office environments and more.

As if that wasn't enough, there's a new eBook reader (based on KDE's rather wonderful Okular), a news reader, an alarms application and numerous improvements to the applications we shipped previously.

Another extremely noticeable improvement is performance. Many applications in Plasma Active One and Two would take a rather long time to launch; you'd tap a launcher and then tap your fingers on the table as the little spinner spun and spun. With Three, things launch much faster. The file manager, for instance, launches in just over a second, as does the ebook reader, image viewer and others. We've hit upon a winning combination for how to get things launching quickly and their interfaces moving more smoothly. You'll see this in more and more of the applications we ship.

Part of our performance gains have come from moving to a new reference operating system base: Mer Core. This is the community continuation of MeeGo and a number of companies are actively working on and with it these days. The community itself has a potent mix of friendliness and competence that makes it a wonderful group to work with. It also has brought us into the modern age of Linux technologies. Faster boot times are nice (up-to-date kernels and systemd help here), but so is the ability to set up VPNs and have proper (read: high resolution) screen DPI. We integrated the Maliit input framework, giving Plasma Active Three a new keyboard that is faster, works with all applications you might install (including non-Qt ones) and gives us a really solid foundation for mobile input. As a bonus, the Maliit people have also proven to be an approachable, professional and enjoyable group of people to work with.

In between all these larger chunks of work, we also spent a good amount of time and effort improving the small things, such as where buttons appear in the sheet-style dialogs we use, how applications are listed and the visuals of certain animations to name a few.

As you can see, this is a big release and we hope you enjoy using it, tinkering with it, making new things with it and joining us in making it even better.

You can find out more about Plasma Active Three on the official website, including how to get it and get involved with the community behind and around it.

Read More

Randa begins and Lernstick

The sun has risen this morning to reveal the beautiful valley which a some 20 or so KDE community members have gathered to work on 3 main topics (multimedia, accessibility and Plasma). People were awake and hacking here in Randa until the early hours of the morning of our first day here. In the Plasma room we spent the day catching up with each other and what we're working on as well as starting in on libplasma2, the next version of the underlying Plasma library, with the goal of having it in top shape for inclusion in the first release of Frameworks 5.

We also have some people who have joined us that haven't been involved in upstream KDE very much but who are involved in Free software and use KDE technologies in various ways. One example of this is the Lernstick initiative which brings Free software (and KDE! :) to students around Switzerland in the form of a handy, self-contained USB stick. They are now working on making this available on tablets as well, and one of the people behind the project was kind enough to give us a quick demo of the live login feature:

Today we continue on, with most of the people staying for the whole week to work on improving KDE and Free software for the masses. This meeting was made possible by Mario Fux and his wonderfully supportive family here in Randa who take amazing care of us (and make some very tasty food :) as well as the over 10,000 Euros in financial support provided by the KDE community. Our thanks to everyone who makes these meetings possible so that we can in turn make more, and better, Free software.

Read More

a small update on Vivaldi

What a crazy year it's been for our little Vivaldi tablet project. Lots of ups with Plasma Active developing by leaps and bounds, with version 3 coming out this month and many of our efforts starting to improve our other form factors such as Desktop, and so much learning with regards to the state of the hardware world in Asia.

With our chosen hardware, we dealt with the completely typical (for the industry segment) GPL violating company which we negotiated with to change that ... only to have them simultaneously renig at the last minute and, while introducing a new revision of the board not only break our prior work but noticeably decrease in build quality. This was a massive, massive set back for us.

We didn't give up immediately, but kept banging our collective head against that particular wall until we exhausted all rational options. We began looking at various other options in the meantime for hardware production. It's been a grueling few months, which at one point was one contributor to my health generally failing forcing me to take a number of weeks away. (I'm feeling very good and all in one piece again, in case anyone is wondering. :)

Armed with the things we've learned from our first go-around, we began exploring  the Asian manufacturing world again. I've noticed a few differences this time: first, I'm able to ask the necessary questions a lot more effectively, and as a result get rather better answers. I'm also able to read between the lines a bit more effectively as I learn the business lingo of this sector's culture, which really also helps.

But recently a really eye-opening thing happened. One person I'd been working with previously contacted me, said they had recently moved to another company that also produces the sorts of electronics we need and started with "... and we have source code."

This was the first time I'd had a company at this level in the game approach me with that line. Are we, collectively, getting through to them? Maybe. One person, one company, one effort at a time.

I'm not going to say anything about the hardware we are looking at using. Last time that didn't turn out perfectly, so this time we'll wait a bit longer before sharing that information ... though I expect that when we start sending devices around to people for demos and engineering work that it will still come out. :P Anyways ... what a ride, but we aren't done yet.

In fact, that is a question I've had to stare down a few times: Is this worth doing still? In times when things look completely bleak and you've just had your most recent negative answer handed to you, that question pretty much finds you without you going looking for it. I've found my answer to it has shifted over the last few months. For a brief period of time it was, I'll be honest, "No, it is not worth doing." I hated that answer, though .. it felt unnecessarily wrong. So I dug more and the combination of seeing that the tablet space is still very much open (with all sorts of speculation about Android's position in it, Apple's ability to keep a death grip on the space, the rise of Amazons and others, etc..) and the reaffirmation that if we don't make open devices who will, I feel it is more important than ever to keep going.

After all ... someone came back to me and started their sales pitch with ".. and here's our source code." Halle-fucking-lujah.

Read More

supporting Randa 2012

Others have blogged about this already, but I don't think enough can be said about it. A quiet tradition has arisen in the KDE community: a yearly developer meeting in Randa with dozens of people in attendance. This tradition goes back three years now, with the fourth installment of the Randa meeting happening later this month.

The Randa meetings have hosted discussions on KDE's libraries, Plasma, multimedia, messaging and more.
These discussions resulted in significant decisions being made that were unlikely to be achieved with the quality and quickness experienced at such a meeting. Those decisions translated into improvements in our software ... a lot of improvements. This time around the topics in focus are education, accessibility, multimedia and the Plasma Workspaces. Each of these four topics has a group of committed developers and contributors coming to Randa to work on them. Yes, it's four developer sprints in one!


What's also makes Randa special is that it is amazingly well coordinated (which significantly contributes to the quality of the results), it is in an awe-inspiring location in the Swiss mountains which not only puts everyone in a great frame of creative mind but also limits distractions  ... and it does all of this in a rather affordable package given the number of people who attend.

This year, the organizers (led as usual by Mario "unormal" Fux), are trying something of an experiment to help with fund this important event. They are going straight to us, the users and supporters of KDE and Free software, and asking if we can help support this meeting financially. We can't all be there in Randa, we can't all contribute effort directly to Free software projects, but we all benefit from these efforts and many of us do have the ability to pitch in financially to ensure that those who do the work are given the best opportunities possible to do so.

The goal is to raise 10,000 Euro ... and well over half of that has already been pledged. Please support this important event if you can. Every Euro is a direct investment in the future of the technology we all rely on. You can visit the pledge page and make a donation here.

Read More

nobody will do it for you (and therefore they will)

There's an interesting paradox in many social cooperations that is readily observable in open, participation-driven creative projects (for which open source software is often held up as the poster child): nobody will do it for you. In F/OSS, that assumption translates to things like "nobody will write the patch for you" or "nobody will fix that bug for you". It turns out that this is the only safe assumption to hold.

But that idea flies in the face of reality: tens of thousands of bugs are fixed in Free software code bases around the world every year; huge numbers of features are added to free software code bases on a regular basis. Yet most of the people who use Free software did not perform any of the work that went into it, and those of us who do put effort into it are never responsible for more than a tiny, tiny fraction of the global result. So obviously people will and do make things for us. I have DVDs full of the stuff; I use it on all the computing devices I own every single day. You probably do as well.

This is where the paradox kicks in: the people who do the work specifically did not assume that someone else will do it for them. They assumed that they ought to do the work so that it actually, you know, gets done. For the person writing a patch in the quiet of their office, dorm room, house, local coffee shop .. (you get the picture) .. nobody did it for them. In fact, if everyone who adds to the body of Free software simply assumed someone else would do it, there wouldn't be much Free software out there at all.

Interestingly, some of the early Free software nay-sayers used to boggle at this concept of "making stuff for others" and would present it as a "logical" proof that Free software was obviously not happening because it was not realistic: "Why would anyone do it for you? Of course they won't!", they'd say, "Therefore Free software won't happen."

Indeed, in spite of the disbelief, people do realize that it is up to them to make things happen, that it is unrealistic to wait for it to magically occur at the hands of others and so they dig in and get it done, thankfully often with great joy. (Most of us working on Free software love what we do.)

By assuming that it is up to us and therefore taking on the responsibility of doing it ourselves, we prove ourselves wrong in way because we have just, indeed, done it so the majority doesn't have to. If everyone  suddenly grew complacent and decided that someone else somewhere would do it all for us and therefore we don't have to anything, then we'd be wrong all over again because nobody would do the work and nothing would get done.

What can appear as a delicious paradox is the triumph of self-motivated participation: it is people accepting that it is possible it could never happen if we all wait on each other, rejecting that as an acceptable result and so doing what needs to get done to make it happen. Put another way: stuff happens because people realize that it won't. Maybe it's just me, but I see a certain kind of heroism in these acts of self-motivation that end up benefiting others.

"Patches welcome," indeed.

Caveats

Yes, there are caveats to the above discussion, such as:

• many participants do things for "selfish" reasons, such as "scratching their own itch"; however, that does not change the fact that by making the result available as Free software, that act can (and usually does) benefit others who didn't have to do anything to receive that benefit, and that the person who did the work took it upon themselves to do it rather than wait for someone else to do so.
• some people write software out of enjoyment of the act itself: even if there are a thousand other text editors out there, there are people who will write another one just for fun. While true, in my experience most participants are not entirely free of practical motivation, so while this is an interesting phenomenon it is not enough to explain the amount of Free software (and the output from other participation-based communities).
• not everyone involved is self-motivating. This is true: some people are doing it because it's a job or require regular guidance and external motivation. I would assert that behind those people are individuals (usually large numbers of them) who are.
• there are many ways to make "code get written for me" that doesn't involve actually "writing the code"; for instance translating text, doing promotional work or providing project support services has a direct positive correlation to the rate of participation. So does hiring a developer with money. I would classify those acts as examples of "doing it because nobody else will" which are of equal import and primacy to the act of writing the code that forms the body of software itself (or whatever the end product of the project is intended to be).

I do not believe that the above caveats significantly alter the basic point, however. :)

Motivation

What made me think about this today of all days? Well, I was on IRC again for the first time in quite a while and I saw a number of people discussing patches, improvements and bugs as if someone else might suddenly appear and make it happen. That got me to thinking about the paradox outlined above .. and I love a good mind tease like this one.

Read More

ideas to build content stores on

In my last blog entry I wrote about building communities on ideas that tie the individual actors together, and letting those communities of individual actors interact freely, guided and driven by those ideas. I'd like to share with you one of two ways we're trying to bring that spirit to a practical result with the Make·Play·Live Add-Ons system.

First, though, a little update on the app itself in a screencast I hastily threw together for this blog entry to show some of the improvements made to the application since the last screencast. You can grab the original ogg recording here, or watch it via youtube below:

A couple years back, I spent a lot of time thinking about "app stores" and this led rather organically to the broader topic of add-ons of any type: books, graphic art, music, applications, widgets, services ... what principles should it embody, and for whom?

Free(dom) Software

Societies that rely on technologies for processes impacting basic human rights must be open for all to use, to review and to modify for their specific needs. To forgo any of those things means trading rights that should not be negotiable in exchange for tools. This is a very poor exchange and would very likely eliminate the possibility of free societies with strong guarantees for human rights.

The add-ons system respects this in a number of different ways. Firstly, the implementation itself is Free software. The implications go way beyond being able to make client apps that integrate well with a given system, as the above Add-ons App does with Plasma Active. It means that other entities can also host their own content and other add-ons in their own database. This result of freeing the server side code will mean there is no single point where censorship or decisions made against you can be erected. It also means that those whose needs we can not take care of, say the needs of a specific educational environment or a specific community's needs, will be able to build those services.

However, there is another way we can support Free software: by promoting it in the catalogs. We show the licensing of applications directly, will be allowing you to filter based on Free-ness and will promote Free software applications to the device owners who are using the Add-ons App.

Keep in mind that Free software can be sold, and on devices such as these getting software that is tested and well packaged is a service much like bottling water. Yes, water can be had at no cost, but the convenience and safety of bottled water makes it something you can sell. So while we are shipping a ton of great Free software applications by default as part of Plasma Active (and therefore the Vivaldi tablet) so that it is useful out of the box, we are also going to be encouraging developers of Free software to think about putting a small price tag on their applications in the catalog.

The idea of voluntary payments, or "pay what you feel", has also come up and is something we've discussed. It isn't in the first version of the software, but I rather expect it to show up eventually. It will be interesting to see how well that works.

Free(dom) Culture

Freedom doesn't begin and end with software, though. We are big fans of Free culture in general. There are a few reasons for this. First, we like sharing stuff with people and really enjoy experiencing the creative efforts of others. It's thrilling and enjoyable and highlights how "Make" and "Play" fit together so well.

That would be enough on its own, but there are other reasons to support Free culture. By sharing openly and broadly, society as a whole is enriched and entirely new and powerful works can be derived from this commons. Shakespeare didn't invent many (any?) storylines, but he took old themes and made them amazing, immortal. Disney as well tapped the large body of existing children's fiction that was in the commons to create animated films that many consider masterpieces. A society with Free culture is a society that invents more, creates more and is richer as a result.

This does not "just happen" on its own, though. Free culture needs to be supported. So we have put a focus on making Free culture works available, even if they may not draw a single penny for us. It makes the experience better for those of us using it and helps invest in our culture.

We've started with Project Gutenberg, but that will only be the beginning. Which brings up another interesting topic: federation of data.

Open Participation

Central storage of all the data is OK, but then we would once again have another silo, albeit one that was rooting for freedom. A rather more enticing concept is being able to have data that is worked on and exists outside our little silo available through the add-ons system. This allows greater opportunities for people to participate in their own way, in specialized communities, while bringing our audience to their doorstep.

With Project Gutenberg, they are doing a wonderful job of digitizing books left and right. There is no need for us to get in the way of that. So we mirror their content and make their catalog available to our audience. I contacted them about this and they were wonderfully supportive of the idea. And why not?

The system can already handle installing software from third party repositories, which will bring software communities using OBS into the same sort of relationship. Imagine: hundreds or even thousands of different communities working whatever it is they do, and able to be syndicated into a seamless whole by hundreds or even thousands of add-ons stores around the world in hundreds or even thousands of different constellations? Wow!

In the coming weeks we will also be unveiling the developer program. There will be no up-front cost to participate, and aside from illegal content we won't be telling you what you can and can not be sharing with others. You can upload what you make.

Of course, the audience needs to be taken care of and it would not be fair to them (which also includes us ;) if there was just an unfiltered firehose of whateverness sprayed through the Add-ons App. We designed the system so that catalog owners have tags which they can put on any content they want in their catalog.

This balances the participation of those making content available with the participation of those delivering the content. The result? One body of globally federated content that can be presented in an infinite number of catalogs that meet the needs of different audiences.

If a catalog owner doesn't like fart apps, they can filter those out. If a catalog owner wants only to show HTML5 apps, they can filter only those in. But nobody tells you what kind of app you can write, what sort of book you can author, etc.

tl;dr

None of this is ground breaking philosophically. It is simply the re-application of well known principles from and attributes of Free societies to an add-ons system. But that required us to identify that those attributes ought to be in an add-ons system, and to develop that system from those principles as the first principles of the system.

It is also not enough to only be content with the application, in this case the add-ons app, itself being free enough. It is critical to consider the network effects and social interactions that are implied by the design. We live in a networked world and we are building the tools of togetherness, the tools of culture. It is therefore a requirement that we start designing with respect for the responsibilities that comes with.

We also believe that when you do that ... the results can only be more compelling.

p.s. 

I forgot to add some links that I had meant to .. so here they are:

Creating systems of support for Free culture is a trending topic. Just yesterday I came across Bryan Lunduke's project to move to a completely Free software approach for his work. This is a big gamble for him, but he's betting on an ethical route and I have mad respect for that. It shouldn't be a gamble, however, and we can change that dynamic by building systems of support that can free people of the temptation to hold their their own work hostage. I'd rather see people able to participate easily in  free culture without making unreasonable financial sacrifices. This relates to our thinking on supporting Free software and Free culture in the add-ons system.

If you are interested in getting involved with the Big Picture ideas around the add-ons system and how it impacts mobile device usage, please join us over at OpenTablets to discuss it with us in the forums!

Read More