Inspirations from FOSS.in 2012

a young visitor to HampiI’ve attended FOSS.in in Bangalore two weeks ago. FOSS.in is the largest Indian Free software conference, and has been on my list of conferences to ever attend for a long time. I’m back home for a good week now, so it’s time to recap a bit my experiences there. I travelled together with Lydia, a.k.a. Nightrose, who was attending on behalf of Wikimedia to tell about Wikidata. For the conference, I was scheduled for a talk about Plasma Active, and we also did a workshop on creating device-adaptive interfaces. More on that later.

Lydia and I went a few days earlier, to have some time to see Bangalore and surroundings. It was my first time in India, so also a good opportunity to see a few new things here and there, and to acclimatize. On the first day, we went around the city a bit, and later were invited to PES-IT, a renowned Indian IT college, where a 24hour open source hackathon would take place. Lydia and I held ad-hoc presentations about getting involved with KDE and Plasma Active respectively, followed by hands-on demos and discussions about both technical and non-technical issues. The students and professors were very friendly, and it was awesome to see enthusiastic students spending their weekend together hacking. We only arrived late at night back at our hotel, after some long and enlightening discussions about Free software and Indian culture. What struck me in particular (and in a very positive way) was the number of girls attending, about one third. In most “Western” countries, information technology is very much a male trade, Dutch universities for example struggle to attract more than one or maybe two girls each year for their computer science courses. India is way ahead there, which on the one hand is great to see, but on the other hand raises the question what is going wrong in my home country. Free software communities suffer from the same skewed demographic, so the same question applies here.

Hampi

Jean-Baptiste (j-b) of VLC arrived two days after us, and we all hopped on a nightbus to Hampi, a UNESCO heritage site, an old capital of a long-gone empire and religious centre a few hours North-West of Bangalore. There, we spent an unforgettable day, from watching (and participating) in the morning ritual of washing your body in the river, sipping a glass of chai, having a wonderful breakfast under the Mango Tree, watching temples in a beautiful surrounding, more wonderful curries, chais, temples and friendly people to enjoying the sunset from the top of a mountain.

Aakash

On Thursday, FOSS.in started. One of the booths that struck me first was the stand of Aakash, which is a low-cost tablet meant for students. The tablet is procured by the Indian government under the supervision of the Indian Institute of Technology in Bombay (IIT-Bombay). It is running a dualboot Linux/Android system right now. The Aakash people have already looked into Plasma Active (they prefer it much to Android, but there were some problems getting it to run on their hardware. The hardware is a 7″ tablet with a a capacitive screen, 512MB RAM and otherwise an Allwinner A13 chip with Mali400 GPU. That should just be powerful to enough to run Plasma Active. I got demoed a few applications, both under Android and Linux which quickly revealed why Android was not the best choice: Android basically made a lot of apps run 3 times slower. In the course of the next days, I sat down with IIT’s developers to look into problems they had with getting PA to run. We made some progress, and fleshed out strategies how to get it to run. One bigger hurdle is the lack of a good graphics driver, other tasks involve “relatively simple” system integration tasks. Doable, it seems, and a wonderful opportunity to bring KDE’s software to a very large new group of users.One thing that struck me as genius in this project is that it is not limited to procuring hardware and getting it to boot, but a large part (60+% of the budget) is allocated to content creation. Software is created under the GPL, content under Creative Commons, non-commercial licenses. Translation of content is an integral part of the project, so this initial Freeing of educational content has the potential of being very useful far outside of India as well. Visionary.
As with any big project, there are also critical voices. Hardware is one issue, building a relationship of trust with Chinese manufacturers is not easy, as is getting the manufacturer to understand the constraints and requirements of Free software. I wish the Aakash project all the success it needs however, and we will continue to support the goals of the project. This could be the beginning of a wonderful thing. :)

Plasma Active Presentation and Workshop

Holy cows feeding on trashOn the first day, I held a presentation about Plasma Active, its approach, technology, goals and so on. The talk took place in the main hall and was well attended. I collected some valuable feedback, and am happy that people understand the ideas and believe them to be right. The next day, we held a KDE miniconf, where Shantanu and me did a workshop on developing device-adaptive apps. In the workshop, we outlined the process from idea to running code on a device, and dug into details. We had about 50 interested visitors, the workshop itself was quite interactive, and we did some live-coding, it was a lot of fun to do.

conf.kde.in 2013?

During the conference it became evident, that the Indian KDE and Free software community would very much like to organize an Indian KDE conference again. After conf.kde.in 2011, which was a great success, this seemed like a good idea, so we did some planning on that, asked if people were willing to volunteer in the organization and outlined a few possible options. The discussion has moved on to the kde-india mailinglist, so if you are among the people who would love to see conf.kde.in 2013 happen, join the list and add your ideas and man/girlpower!

The Internet of Things

One of the presentations I attended during FOSS.in was by Priya Kuber, who works for Arduino. Arduino produces a open source hardware microcontroller aimed at educational purposes. The talk was very inspiring, so I wondered if I could use this for some home automation tasks, as simple example a remote power switch to turn on my workstation in the office, or somesuch. Priya sat down with me and quickly got me going with my own basic programme for the Arduino microcontroller, and it was all very easy and fun. Back home I ordered an Arduino starter kit, which has already arrived and contains basically what I’d call a kid’s microcontroller wet dream, it has the Arduino Uno board, LEDs, sensors for light, temperature, an LCD display and a bunch of other small electronic components along with a nice book. Surely something to spend the calmer Christmas days with, old style. :)
Still in India, I sat down for an afternoon and hacked up some code to use with this little project, and got already quite far. The idea is to connect the Arduino to my RaspberryPi (which is energy-efficient enough to run 24/7), run a small http server on the RPi and use that to remote control physical devices at home from a remote location (I’d like to think of a tropical island here ;)). I’ve implemented the server in twisted Python, it presents a JSON interface, which can be directly consumed from a QML Plasmoid, on either my laptop or any Plasma Active device. I didn’t get around to doing the actually interesting hardware part, yet. Maybe this is the feable start of using KDE technologies for home automation and domotica?

I would like to thank the KDE e.V., the foundation for the KDE community, for supporting my trip. You can also pitch in here, to make participation of KDE contributors in this kind of events possible by Joining the Game.

Randa Meetings 2012: The Future of QGraphicsView in Plasma

I’m on my way back from the Randa Meetings, where a few teams in KDE came together to collaborate on the next steps in their respective subprojects. I’ll post this to my blog after arrival, but as I’ve got some time to kill here in Basel, Switzerland, close to the German border, I decided to recap what we’ve been up to in the past days. I’ll concentrate on what the Plasma team has been working on. Present were Marco, Aaron, Afiestas, Giorgos, Antonis and myself. Giorgos and Antonis are still relatively new to the Plasma team, they concentrate on on making Plasmate rock, but have also done some excellent work this week on libplasma2. I’m happy to see the influx of enthusiast and skilled new developers in the team, as that reduces the busnumber and makes it easier to achieve our audacious goals.

Peak up to the glacier from Randa
Speaking of goals, we came to Randa with the plan to achieve a critical mass towards libplasma2. But what is libplasma2 exactly? Well, while we had some plans where to go with it, there were still a few items unclear — but not anymore! One of the big ticket items was the future of QGraphicsView in Plasma. QGraphicsView had been introduced in Qt 4.1. It’s basically a canvas on steroids, that gained features to create a fluid, widget-based UI using it. In Qt4, QtQuick uses QGraphicsView as its rendering backend. QGraphicsView is heavily based on QPainter, and employs a procedural way to rendering the UI. In Qt5 and QtQuick2, graphical display is supposed to move to an OpenGL scenegraph, making it possible to move much of the work involved to display a UI into hardware, so your GPU can do its magic with your UI. The benefit for the user is mainly that we’re able to have a much better performing rendering engine underneath (so smoother graphics), and more CPU time left to do the real work of your application. (One side effect will likely also be that we save a bit of power on mobile devices, as the GPU is much more efficient in doing these tasks – it has been optimized for it. (Experts say that the saving is in the range of an order of magnitude. Wether or not it will be noticeable to the user in the end, we’ll have to see later.)

As the OpenGL-scenegraph-based rendering is an entirely different paradigm compared to the procedural QGraphicsView, we have to rethink our use of QGraphicsView. Unfortunately, QGraphicsView is deeply ingrained into Plasma’s architecture. Even more unfortunate is that it’s not as bugfree as we’d like it to be, in fact much of the occasional rendering glitches you sometimes see in Plasma-based UIs are caused by QGraphicsView problems. Moving away from QGV and towards scenegraph is likely to solve this whole class of problems.

So one thing is clear, we want to move towards scenegraph. But what about all the old, QGraphicsView-based code? Well, we already started moving components of Plasma Desktop one by one to QML. This has begun with Plasma Workspaces 4.8, a lot more has moved in the 4.9 cycle, and yet another batch will move with 4.10, which will be released in January 2013. Our credo has been that we want to ship feature-equivalent ports, in order to keep the impact for the user as minimal as possible. There will be a point, however, when we will have to remove support for QGraphicsView in libplasma, and that will likely be libplasma2. We expect this work to take still more than a year, so also third party developers get ample time to move their code to the (much nicer) QML way of doing UI. But why not keep support for QGraphicsView? Well, it’s not that easy, as scenegraph and QGV are due to their respective paradigms more or less mutually exclusive. We’ve spent quite some time trying to come up with solutions that guarantee maximum amount of backwards compatibility, but we also had to ask ourselves if we have the manpower to implement and maintain workarounds for the incompatibilities between scenegraph and QGV. Moreover, what would the impact on our APIs and our code be? the tradeoffs were quite horrific, so in the end we decided to bite the bullet, and remove QGV from the frameworks5 branch. But what will Plasma2 with out QGraphicsView become? What we came up with is actually a very neat and clean approach: Our classes that currently manage the workspace (Corona, Containment, Applet) will become abstract managers that concert how components work together. Containments and Applets will have their UI written in QML (so we can do the rendering in the scenegraph, thus in the graphics hardware). They are extensible through C++ and various scripting languages that have bindings for Qt. This way, you can choose to implement the business logic in your favourite procedural language (C++, Python, Ruby, QtScript, etc.) and do the UI in a declarative way. Things like theming, localization, distribution, and all that will still be offered by the platform.

Clouds descending into Randa

In Marco’s preliminary branch, where he removed support for QGraphicsView from libplasma2, the result is quite spectacular. The library is already about 30% smaller, and will likely lose another big chunk of code. That means more maintainability, a smaller memory and disk footprint and faster startup. As the functionality of QGraphicsView is more or less a subset of what we can do with QML, it’s not any less powerful or flexible. Just smaller, leaner and meaner (and also a bit easier to grok for developers using our APIs).

As you can see, we have been quite productive during this year’s sprint in Randa, and the above is only one part of what we’ve worked on. We’ve also made quite a dent into our TODO list for the KDE Frameworks 5 port, reviewed lots of patches, fixed bugs left and right, made existing code faster, and caught up with each other on various side projects. This all would not have been possible without the sponsors of the event, and the 287 people who donated through our fundraiser campaign to make this great event in a scenic location possible. Thank you all!

FISL13: Civil Rights and Plasma Quick

After a nice stroll through downtown Porto Alegre with a few fellow Free software activists from Spain, Mexica, Peru and Argentina, today was the first day of FISL13, and it was amazing. My usually screwed up biorythm in this part of the world means that I get up at a reasonable (for a conference visit) time in the morning, enough to have a relaxed shower, a bit of emailing, breakfast and still be on time for a fully packed conference day. FISL’s first day was amazing, it started off by meeting a few well known faces (Sandro, Filipe, Isabel, Knuth, I’m talking to you!), and getting to know a lot of new ones. Especially the Brazilian KDE community is really awesome (I knew that, but doesn’t hurt to mention it nevertheless). I also went by SOLAR, the Argentinian Free software organisation who offered me a nice cup of Mate tea, and an opportunity to share some ideas by means of an interview.

After a bit of booth-crawling, I went to attend two talks, which were both really excellent: The first was by Seth Schoen, who is with the Electronic Frontiers Foundation (EFF). Seth talked about privacy and data security at the United States Border. I’m sure anybody who has travelled to the U.S. in the past 10 years can relate to that. Seth explained how the border control is organised, what your right are (at the border, your normal civil rights are actually limited, so searching your luggage or detaining you for questioning can be done without good reason, unlike “in the streets”, so it’s very good to know what they can and can’t do), and how you can protect yourself in case you *DO* have something to hide (or rather, how you carry private information on digital devices across the border). There are a few methods, one is: wipe your device, do a clean install and download the interesting data only after you crossed the border, more sophisticated tricks involve temporarily encrypting your device with a key you don’t know and only get after you’ve passed through border control. Lots of interesting information there, and it makes me more comfortable when travelling to the U.S. the next time. Also, chapeau to the EFF for their protection of privacy and civil rights in general. The talk was excellently held, really interesting and absolutely worth my time.

Next up was Rick Falkvinge, one of the founders of the first Pirate Party (in Sweden). Rick talked about the history of copyright, how people who gain power all of a sudden “kick away the ladder” to secure their position, and how, in more general the Internet changes society. Another excellent talk that felt like it was really worth the time spent. Interestingly, these days, the Brazilian branch of the Pirate Party is being founded, so it’s very much a historical thing happening here. Excited to witness that.

Later in the afternoon, Daker Fernandes Pinheiro of Plasma Qt Quick Components fame and me did a workshop teaching everything you need to know to get started writing device-adaptive applications using Plasma. The workshop was well-attended, I think well prepared as well and people seemed to like it (even if we flooded everybody with a lot of information). It was quite practical, luckily Daker and me hit the right audience, so I think even if it was quite heavy on information, it’s still manageable. After a good two and a half hours where we taught the basics of Qt Quick, Plasma Quick, and how to write Plasma Components and Apps, it was evident on the faces of our audience (and judging by their questions) that people enjoyed our sharing of knowledge, and who knows, maybe a few of the attendants will join our team and become new KDE hackers. As promised, I’ve put the slides online. They provide a good overview of the technologies involved, so are probably quite useful as reading material. Of course, as sharing is good, let me know if you would like to reuse them in part or as a whole, and I’ll send you the sources (including a bit of example code). I myself enjoyed “teaching” as well. Especially Plasmate, our one-stop-shop workflow-driven Plasma IDE resonated really well with the audience, just in time for the end of this summer’s 1.0 release.

Overall, I’m really exhilerated by FISL so far. People are more than welcoming, so it immediately feels “at home” (at 12.000km away from it!), I’ve had really interesting and inspiring conversations, and everything is really well organised. I’m now at my hotel (one that focuses on sustainability, it’s really nice, well done FISL peeps!), we’ll go for churrasco in a bit and then off to the first night’s party.

My talk on “Freeing the Device Spectrum” will be on Friday, at 11.00 o’clock in the GNU hall (that’s the big auditorium). It’s targeted at a general audience, so a lot less technical than the workshop we did today. Be there, or be square!

Back in Brazil

I got up rather early this morning to catch a flight from Amsterdam across the ocean (and equator) down to Brazil, where on Wednesday FISL (Forum Internacional Software Libre) will start. Right now, I’m temporarily stranded in a bar at Sao Paulo airport, waiting for my connecting flight to Porto Alegre where FISL will take place.

Already a few years back, I heard that FISL is one of the pearls among international Free software events, and this year, fate (impersonated by the FISL organizers) invited me to speak at FISL, a wonderful opportunity. Doing bit of research, FISL is an order of magnitude bigger than European events, which due to geographical proximity are a bit more often on my agenda, so I’m quite excited to celebrate this Planet’s biggest community-driven Free software event, and I’m honoured that I will get the opportunity to present our ideas, work and progress on Freeing the Device spectrum to the audience (mark down “Friday, 27th, 11.00h, auditorium” in your agendas!).

Brazil has a special place in my heart, I’ve been working together for a few years with many awesome Brazilian hackers and contributors, I’ve had the opportunity to visit this huge country earlier (when I keynoted at OpenBossa conference in 2009 in Recife) which I’ve fond memories of. I’m glad I’m back now. (Although it’s not quite so real yet, airports are quite the same everywhere.) I’ll arrive at my hotel in Porto Alegre quite late tonight, will hopefully get a good night of sleep to counter the jetlag, and a day tomorrow to acclimatize and possibly visit the city.

On Wednesday, Daker Pinheiro and me will be running a workshop about developing apps for the device spectrum using KDE technologies. For this workshop, no prior knowledge of Qt or KDE technologies will be required, we hope to be able to get you going with the basic steps and concepts during that workshop, so that attendees get a kickstart and can continue this fun adventure when they’re back home, supported by our many online support channels (docs, email, IRC, wiki, read-the-source-luke, etc…)

The weather back home in the Netherlands has been mostly aweful, quite a crap summer indeed. Let’s see if Southern Brazilian winter beats this year’s Dutch summer…

Plasma Active Perspectives: The Developer Story

Plasma Active brings a flexible, elegant, activity-driven user experience to a spectrum of devices. This article is part of a series of articles about different perspectives on Plasma Active. This installment looks at the user story, and aims at answering the questions “How do we get developers interested in Plasma Active?”.As I’m quite a bit behind on my series of perspectives on Plasma Active, so let’s try to catch up a bit. I’m trying bit of an experiment Marco and I talked about last night: Using personas not only for user stories, but also for our developer story.

Chad – The Casual Developer

Chad is a 23 year old developer. Chad has basic (but much to his regret not highly advanced) programming skills. In order to manage complexity, he mostly works in JavaScript. Concepts like cross-compiling code, packaging and deployment are alien to him, ideally he can avoid them entirely. Chad’s main interest is to transfer cool ideas for apps he has into reality. Chad does this work next to his studies, as Freelancer.

Chad’s IDE of choice is Plasmate, a simple IDE entirely geared towards creating Plasma addons. Plasmate guides the user to the whole workflow: creating a new app template, coding the app, testing it and deploying it to one or more target devices, and publishing it using online services. By providing these features all in a single tool that is small and easy to install, we maximize Chad’s gain for the brain he put into the code. While Plasmate is (purposefully limited to “pure scripted” Plasma components (such as Plasmoids, apps) it takes away most of the system learning and allows to fully concentrate on the creative process. Resulting applications are platform indepdenent and can easily be installed on test devices, directly from Plasmate. Complexity of the process is reduced as much as possible. The powerful KDE Frameworks allow to include advanced functionality in Chad’s creation, resulting in rich and visually appealing apps.

Lwing – The seasoned app developer

Lwing is a seasoned C++ developer. She has been working on various mobile and embedded platforms, as well as desktop applications. Lwing would like to bring SqueezeIt! one of her own desktop apps to a wider range of devices. For that, she chose Plasma as being the only truely Free and open system in the world. (Yep, shameless, shameless plug :).

Lwing’s way to success involves a bit more complexity. The recommended way is using the Mer SDK and Open Build Service (OBS) to cross-compile her code and get it deployed to devices. The Mer SDK is quite easy to set up and provides a build environment that produces reproducable results and takes away a lot of the complexity (and therefore pain) from the process of deploying an existing app to a new system. Combined with tools such as KDevelop or Qt Creator and supported by lots of excellent documentation, for Lwing, sky is the limit. Lwing thusly refactors SqueezeIt! to strongly separate data, busines logic and presentation. She designs her UI so it scales to different screen sizes, and implements it using Plasma Quick (Qt Quick plus Plasma QML Components). Libraries and development packages Lwing needs are already pre-installed in the SDK, so she doesn’t have to worry about that, other than updating the SDK once in a while from withing using the zypper package management tool. For usability and design questions, Lwing consults the human interface guidelines, which make it easier for developers to create applications that feel like they belong and are consistent with existing components. When she’s happy, she offers the app through her OBS project, and uploads a premium version with a few more advanced feature for a little money in the Make*Play*Live Addon Store.

Brian – The passionate and talented Hacker

Brian is a talented C++ developer with special passion for gadgets and Free software. He has heard of Plasma Active through a friend, and after hacking a bit on addons, he wants to join the team creating this system. Briann pops up in the #plasma IRC channel on Freenode, explaining his intention and skill level. A friendly developer quickly explains Brian how to get started, pointing him to documentation how to get the development environment set up, API documentation and the team’s current plans, vision and of cource the long list of open tasks. Brian, much like Lwing sets up the environment, plays around with it a bit, changes a few things in the shell in order to get a feeling for the whole thing and starts on some easier bugs. After a few days, Brian is up to speed and starts to send patches to the Plasma team through reviewboard. Fast forward a few months, Brian has shown that he understands the code base, the processes to keep it sane and the team’s vision. He applies for an Git account to be able to take on more responsibilty, helps reviewing patches of other contributors, contributes new ideas and becomes more and more part of the team.

You’ll notice that Brian’s and Lwing’s use cases do not actually differ much technically, but mostly socially and in the sense of community dynamics. This is actually quite convenient, since it reduces maintainance and work overhead: Less development tools to create, maintain, document. Chad’s use case concentrates on lowering the threshold for people to get involved. With the Plasma Quick platform becoming more and more powerful, Chad is able to create a wide range of apps.

Next Iterations of the KDE Workspaces

In this post, I’ll try to provide an overview of the results of the work we’ve done during the Workspace sprint in Pineda de Mar, Catalunya, Spain. The sprint is still going on, unfortunately I had to leave early to attend a friend’s wedding. Before going into any details, a few thank yous and credits are in place: Aleix Pol and Alex Fiestas for being excellent hosts organising this sprint (including picking this terrific location which allowed us to concentrate 100% on our processes and 0% on the beach), KDE Spain for sponsoring our food, the KDE e.V. (and its donators!) for sponsoring travel expenses and providing organisational backing, Kevin Ottens who took a sizable slice of time out of his vacation account in order to facilitate meetings, enabling group dynamical processes and generally being a good moderator, Björn Balasz for chipping in time and providing his background in psychology and usability and of course open-slx, my awesome employer.

Activities central: One focus that we have been working on in Plasma quite extensively is organising your documents, contacts, applications, files and other digital assets into Activities. Activities provide a contextual way of organising your devices. Activities usually enclose these resources into personal context which might include locations, contacts, documents and any other resource we’re able to express in terms of semantics. (So pretty much all. :))
We’ve identified areas where we can improve the activities workflow. Switching between Activities and getting an overview can surely be improved. There have already been some ideas floating around, and some smaller and larger improvements are in the pipeline to see the light of day in one of our future releases. In some parts, we’re transplanting features we have matured in the Plasma Active user experience into the desktop. The Plasma Way: Share code across devices, investigate workflows across apps and device borders. (So a workflow which we want to enable may actually involve using more than one device — we want to make especially these patterns a lot easier, intuitive and fun to use. There’s a few real challenges in there, although many parts involve someone “just sitting down and doing it”.

Personas: I’ve dedicated a separate blog entry to Carla and Raj, our brand new personas, so I’ll kindly refer you to that.

Social networks and messaging: Carla’s and Raj’s lives involve talking to people across different channels. We want to enable these patterns by providing deep integration of messaging and social networks into the desktop. While we likely will not ever support every single feature of all social networks, we definitely want things like native notifications for messages, and being able to keep tabs on the going ons around you. Technologies we’ve been working on in the part years and which are coming to mature now will be a great help in creating a nice user experience here: Akonadi, Telepathy being at the forefront of double-plus-useful frameworks here.

Along with the integration of more social services into the workspace, we also want to enable cross-device workflows using online services. Examples for getting your data across devices are ownCloud, but also commercial services like FlickR. I think we are in the position to put Free software solutions first, but not excluding proprietary services, but enabling Carla and Raj to mix and mesh whatever they uses. In this, we need to pick up the user where he or she is now. We’re not going to switch users to Free software users if we require social disruption in their lives. :)

Something I found particularly exciting was the call by a few participants to reinvigorate Project Silk. The idea is to make the web, web apps, -applications and -services first class citizens in the desktop. This can range from the introduction of a site-specific browser to deeper integration of online content and services: think of FlickR integration in Gwenview, caching data from online sources, providing native UIs for services that are otherwise a bit cumbersome to use, and much, much more. I’m surely hoping we’ll see a surge of improvements in this area. I’m also happy that Richard and I documented our ideas quite well when we came up with them in 2009 at the Desktop Summit in Gran Canaria (coincidentally also Spain, at least technically ;-)).

There’s almost too much exciting new ideas that it’s hard to report about all of it without choking your feedreaders or webbrowsers, so I’ll just mention a few more telegramme-style. Feel free to ask in the comments if you have specific questions, or just head over to the plasma-devel@kde.org mailinglist where you can discuss with the whole team involved.

  • As base for identifying needed improvements, we will concentrate our thinking on which workflows we can enable for users. This first line of identification will be thought about without a specific device in mind. Much more so, workflow can and often do include different devices. We want this to be at the heart of our designs.
  • Virtual desktop will remain what they are, orthogonal to the principle of Activities, We do not plan any sweeping changes here, in order not to break engrained workflows. Nepomuk synchronisation across devices is still a very challenging problem. It needs more design and research work to define an achievable scope.
  • We’ve proposed a few changes to KDE’s release rythms, basically decoupling the releases of workspaces, applications and (in the future) KDE Frameworks. This is basically a continuation of KDE’s effort to implement branding closer aligned to how we work and what we produce; currently under discussion.
  • Notifications will likely receive a rework in order to make them more activity aware, and to display insensitive information on a lock screen, just to name two examples.
  • Everybody agreed that stability and quality are key for users. We will avoid disruptive changes, but concentrate on making existing tools better, and new features not get in the way of existing workflows. A few changes in our processes have also been planned,
  • Clemens of Blue Systems attends the sprint as well, it’s good to see new faces participating and supporting KDE. We’ve had very interesting conversations about all kinds of topics.
  • Maybe the most important thing was the sharing of the Plasma vision with a wider team of contributors. It strikes that Plasma lately has been moving so incredibly fast that we built up a backlog of communication, some of which we managed to knock down in the past days, but it surely will take some time until all ideas, concepts and processes are ingrained into everybody’s brains. The first steps for this have been taken, however.

As you can see, that’s a lot of stuff we have carved in sand in the past days. It will need refinement, and consolidation, more design, ungodly amounts of hacking and surely won’t all be implemented in a whim. It does however give everyone a good idea where we’re going, and what the steps into that direction are. Exciting times ahead. If you’re looking for more sprint results, I’d also read Marco’s blog about it.

Saying good bye was relatively easy this time around, as most people attending the sprint will also be at Akademy, which starts in two weeks in Talinn, Estland. The next Plasma sprint is planned in September in Switzerland. The plan is to mostly work on libplasma2, QtQuick2 and Frameworks 5 in order to technically pave the way into the future of the Linux workspaces.

Plasma Personas: Carla and Raj

Let me introduce two new virtual members of the KDE community: Carla and Raj.

Carla and Raj have seen the light of day at the Plasma sprint in Pineda de Mar in the past days. They are two personas we’re basing our UI work on in order to create software that matches expectations of our users better. Carla and Raj have specifically been designed to represent groups outside of our usual comfort zone. You might also notice that the two are as different as it could possibly get — very much on purpose.

Carla is the administrative assistant of a CEO at a large-ish corporation. She’s a 32 year old university graduate living in London with a monthly income of 5000€. Carla is single, bordering workoholic. During the week, she usually doesn’t have much time for hobbies, in the weekends she enjoys meeting her friends for drinks and fine dining. Carla like convenience of technology but is mostly interested in how it improves her life, not for the sake of technology. She’s smart and interested, but not a techie. Carla’s primary electronic devices are her smartphone, her tablet and her laptop. She uses all of these devices for both work and leisure, the laptop at work docked into a docking station). Her work involves efficient communication, and she always needs to be on top of things. In her freetime, you’ll often find her relaxing listening to music or watching movies and tv shows.

Raj is a 21 year old engineering student living in the West of India, separate from his family. As many Indian students, he shares a dorm with fellow students. Raj has roughly 300€ to spend every month, this covers his costs but doesn’t leave a lot of room for luxurious expenditures. Raj is not too ambitious, in his free time, he regularly gets wasted in one or the other way. Once or twice a year, he visits his family in New Delhi. Although Raj is studying a technology subject, his interest in computers and software is limited. Raj owns a (slightly dated) laptop and a low-end smartphone. Like most of his friends, he hangs out a lot of social networks.

Raj and Carla form the basis of our work. In our design process, which is based on user-centered design techniques, we want to make sure we create software for the right target groups. Having these personas means that we can ask ourselves specific questions when we plan user visible changes. I hope we will see these two fellows deeply integrated in our creation process.

More WACkiness

An example WAC app running in Plasma

After Marco had added initial support for WAC apps to Plasma, at open-slx, we spent a few cycles on taking this to a next level. WAC apps are apps written in HTML5 which are shipped as packaged websites with everything needed included in the package. On top of the normal webbrowser APIs, WAC apps can access a set of API calls that allow access to various aspects of the underlying system, device and network information, contacts, hardware such as camera, accelerometer, location sensors, etc.).

Most of the hard work is already done by the excellent webkit. The parts needed in Plasma and KDE are support for loading the package format, and allowing access to certain system APIs. Marco has written an AppletScript Plugin, which basically wraps the WAC format into a Plasmoid so it can be loaded into any Plasma Shell (Plasma Desktop, Netbook, Active, MediaCenter, etc).

Implementing the WAC-specified APIs turns out to be quite a bit of work. I have started on the DeviceStatus API, and on my laptop, HTML5/WAC apps are now able to access system information such as software versions and battery status. The complete WAC API is quite big, so right now we only support a small subset. The basics are done, and with growing support in this API, we’re able to run more and more apps on Plasma devices.

Plasma asking the user for permission to run a certain app

In the screencast, you see how WAC apps are running inside Plasma Desktop. One interesting thing I’m explaining is the permission model, so I’d like to go a bit more into details about this. WAC apps have the concept of so-called features. The app can check which features are available on a given platform, and then provide or remove features. Plasma’s equivalent to this concept are extensions, which maps a bit, but not too differently. I’ve added a translation mechanism between those two, so what the app is now asking for is access to specific Plasma extensions, very much like our JavaScript Plasmoids.

Everything is running inside a sandbox (in our case a webkit container inside Plasma), so it is quite easy to restrict everything beyond the browser’s DOM API. When working on the permission model, I reflectd about how the user actually handles these permissions. Many people seem to complain that even if the app announces which APIs it wants to access, the user still does not really have a choice beyond all-or-nothing, so most people end up blindly OK’ing whatever the app wants. The code for WAC in Plasma is set up in a way that we can allow access only to certain bits of the API, disallow access or — and that’s the catch — fake access. Fake access means that we tell the app that we support certain APIs, but we will only deliver empty or bogus data, so the app still works, but our address book is not in jeopardy of being sent to some blackhat in a far away country.

Watch on YouTube

Plasma Active Balsam Updates Available

I’ve compiled an update to the Balsam Professional Plasma Active packages in the last weeks, they are now are available for your upgrading pleasure. While the packages work very well in my testing, they are still only development snapshots, so if you’re happy with your current Plasma Active, and you need to be absolutely sure everything keeps working, I’d advise not to upgrade. In all other cases, you’re in for a good performance kick, a lot of bugfixes and a few new, but important features.Instead of boring you, my dear audience, with a long piece of text, I got out my webcam and recorded a screencast of these packages running on my viewtab (an Atom-based 10 inch tablet). Lay back and watch.

Watch on YouTube

In the screencast, I’m showing the general workspace UI, as well as a few new apps and features, file browsing, microblogging, news reading workflows, which we’ve been improving lately.

The packages work fine on wetab and exopc tablets, and most likely also on other Intel-based tablets. Builds for various ARM flavours are available throught the Mer project. As Balsam Professional 12.1 is compatible to openSUSE, they will also work there. If you want to install the packages in your desktop, be advised that this might mess with your desktop sessions, so that’s essentially at your own risk.

The Balsam Packages are made available by open-slx and built and served from our Open Build Service.

new Plasma Quick module: PlasmaExtras

Plasma Quick is KDE Plasma’s user interface toolkit which brings system and data integration, theming and artwork and tools to build workspace and mobile applications to the world of QtQuick. Plasma Quick provides everything needed to build high-quality apps. PlasmaExtras provides an extended set of Plasma QtQuick components.Active Microblog using Plasma Components and Plasma Extras

In Plasma 4.8, we released a set of QtQuick (QML) components that are providing an implementation of Qt Quick’s standard component API. While QtQuick itself only provides very basic components for texts, for example, Plasma Component’s Text Input adds an integrated look & feel to them. Often, you will find that in your app, you’ll also need a few higher level widgets, ui elements with a higher degree of intgration. PlasmaExtras has now been added to our git master tree, so it will be released with KDE SC 4.9 in July.

So, what does PlasmaExtras contain right now? One very important thing is that it adds an image loader, which allows the runtime to resolve theme-internal URLs, such as image://appbackgrounds/contextarea, giving you themed application backgrounds.

ResourceInstance adds support for Share Like Connect. Basically, ResourceInstance exports the currently viewed or active document (or “Thing” really), identified by a url and a name. Share Like Connect provides a standardised mechanism to share and “like” information. It also gives you the tools to connect a document to an Activity, which makes collecting information on a certain topic easy. Adding share like connect support to your application becomes as easy as:

// Example in an imaginary webbrowser
import org.kde.plasma.extras 0.1 as PlasmaExtras
[...]
    PlasmaExtras.ResourceInstance {
        uri: webbrowser.currentUrl
        name: webbrowser.pageTitle
    }

A default set of animations allows the developer to streamline app-internal animations with the rest of the ui. It also allows us to provide a set of high-quality and fast animations, app developers can just reuse them in their ui:

Button {
    [...]
    onClicked: PlasmaExtras.AppearAnimation { targetItem: infoPopup }
}

If you want to do some work in the background while the animation is playing, you can do it like this:

onClicked: ParallelAnimation {
    ScriptAction { script: thisFunctionMayTakeAWhile() }
    AppearAnimation { targetItem: infoPopup }
} 

The ParallelAnimation, which we compose when our button is clicked will start all its children at once. A ScriptAction is not an animation per se, but runs a bit of inlined javascript (usually, you can just call another function here which does the real work). Both are run in parallel, so this pattern can be used to hide computational tasks in an elegant way. This way, you can of course also combine animations, or run them in sequence (using SequentialAnimation { … }).

We’ve also added a few Label subclasses, Title, Heading and Paragraph, which theme the standard Plasma Components Label to provide more consistent layout of static texts.

import org.kde.plasma.extras 0.1 as PlasmaExtras
[...]
Column{
    PlasmaExtras.Title { text: "Fruit sweetness on the rise" }
    PlasmaExtras.Heading { text: "Apples in the sunlight"; level: 2 }
    PlasmaExtras.Paragraph { text: "Long text about fruit and apples [...]" }
    [...]
}

PlasmaExtras QtQuick components

There is also an experimental App class in PlasmaExtras. The goal of this component is a container for apps that is adaptive to the device. It provides a basic workflow pattern around different parts of your app and navigation between them. This is achieved by providing separate areas, such as toolbars, navigation and content. Since we’re still experimenting a bit with this stuff, this one needs a bit more work.

More examples can be found in the gallery app, which is also shown in the screenshot, it’s in the kde-runtime git module under kde-runtime/plasma/declarativeimports/test/. The API documentation gives you an overview about available classes, properties and signals, and also contains code examples. Over time, I expect PlasmaExtras to grow a bit and provide more useful things for developers.

Most of these components have already been in use for some time in Plasma Active. they’ve now “moved up” in the hierarchy being made available on more systems. They are a nice example how work is shared across formfactors in Plasma, and how the Desktop UI benefits from development on mobile systems.

Happy hacking!