July 22, 2017

I've used ngrx/store and ngrx/effects for a while, and like the pattern. The new version has been released, and here are some of the changes I had to make in my code.

Pre v4 you built your reducers as follows, passing an object with

stateslice: reducerfunction.

const productionReducer = combineReducers(reducers);
export function reducers(state: any, action: any) {
    return productionReducer(state, action);}

With the new version, don't use combineReducers. I was running into the situation where the reducers weren't being initialized and the state was null.

Now you create your object of reducers:

export const reducer: ActionReducerMap = {
contactprimary: fromPrimary.reducer
contactselection: fromSelectionList.reducer
contactlist: undoable(fromContactList.reducer),
relations: relationUndoable(fromRelations.reducer),...

and in your app.module imports: [] section


The second big change is the Action type has been redefined.

export interface Action {
  type: string;

This breaks any of your code where you use action.payload. To fix it you have to define Action in each reducer. First define your action classes.

import {Action} from "@ngrx/store";
import {PrintItem} from "../../../models/print.model";

export const ADD_TO_QUEUE = '[Printing] Add to queue';
export const REMOVE_FROM_QUEUE = '[Printing] Remove from queue';
export const MARK_STATUS = '[Printing] mark status';

export class Print implements Action {
    type = ADD_TO_QUEUE;    
constructor(public payload: PrintItem) {}

export class PrintDone implements Action {
    type = REMOVE_FROM_QUEUE;    
constructor(public payload: PrintItem) {}

export class PrintStatus implements Action {
    type = MARK_STATUS;    
constructor(public payload: PrintItem) {}

export type Actions
    = Print
    | PrintStatus
    | PrintDone;

Note that the payload has a type in each one, and it is the same. You can call it whatever you like, or have multiple properties. The type Actions is exported.

Then in your reducer.

import {PrintState} from "../../../models/print.model";import {ActionReducer} from "@ngrx/store";import * as printingActionTypes from "../actions/printing.actions";

export type Action = printingActionTypes.Actions;
const initialState: PrintState = {
    queue: []
export const reducer: ActionReducer = (
    state = initialState, action: Action) => {
    switch (action.type) {

In this reducer, action is of the type defined in your action classes. The same action needs to be defined in the Effects as well.

This requires refactoring much of your reducers and effects. If you have different payloads for each of your defined action classes, lots of changes.

The advantage is strict typing of the data being passed around. It caught a couple minor flaws in my code, and I will be rewriting some reducers to take advantage of the added protection.

Otherwise it all works. The documentation is very helpful, especially with the specific initialization requirements.

I will update this blog after I have refactored the feature module reducers. There are also some improvements in the way selectors can be grouped.

In this article, I am outlining an idea for an improved process of deploying software to Linux systems. It combined advantages of traditional, package mangement based systems with containerized software through systems such as Flatpak, Snap, or AppImage. An improved process allows us to make software deployment more efficient across the whole Free software community, have better supported software on users systems and allow for better quality at the same time.

Where we are goingWhere we are going
In today’s Linux and Free software ecosystems, users usually receive all their software from one source. It usually means that software is well integrated with the system, can be tested in combination with each other and support comes from a single vendor. Compared to systems, in which single software packages are downloaded from their individual vendors and then installed manually, this has huge advantages, as it makes it easy to get updates for everything installed on your system with a single command. The base system and the software comes from the same hands and can be tested as a whole. This ease of upgrading is almost mind-boggling to people who are used to a Windows world, where you’d download 20 .exe installer files post-OS-install and have to update them individually, a hugely time-consuming process and at time outright dangerous as software easily gets out of date.

Traditional model of software deploymentTraditional model of software deployment
There are also downsides to how we handle software deployment and installation currently, most of them revolve around update cycles. There is always a middle man who decides when and what to upgrade. This results in applications getting out of date, which is bad in reality and leads to a number of problems, as security and bug fixes are not making it to users in a timely fashion,

  • It’s not unusual that software installed on a “supported” Linux system is outdated and not at all supported upstream anymore on the day it reaches the user. Worse, policies employed by distributions (or more generally, operating system vendors) will prevent some software packages from ever getting an update other than the most critical security fix within the whole support cycle.
  • Software out in the wild with its problems isn’t supported upstream, bug reports reaching the upstream developers are often invalid and have been fixed in newer versions, or users are asked to test the latest version, which most of the time isn’t available for their OS — this makes it harder to address problems with the software and it’s frustrating for both, users and developers.
  • Even if bugs are fixed in a timely fashion, the likelihood of users of traditional distributions actually receiving these updates without manually installing them is small, especially if users are not aware of it.
  • Packaging software for a variety of different distributions is a huge waste of time. While this can be automated to some extent, it’s still less than ideal as work is duplicated, packaging bugs do happen simply because distribution packagers do not fully understand how a specific piece of software is built and best deployed (there’s a wide variety of software after all) and software stacks aren’t often well-aligned. (More on that later!)
  • Support cycles differ, leading to two problems:
  • Distros need to guarantee support for software they didn’t produce
  • Developers are not sure how much value there is in shipping a release and subsequent bugfix releases, since it takes usually at least months until many users upgrade their OS and receive the new version.
  • Related to that, it can take a long time until a user confirms a bug fix.
  • There is only a small number of distributions who can package every single piece of useful software available. This essentially limits the user’s choice because his niche distro of choice may simply not have all needed software available.

The value of downstreams

One argument that has been made is that downstreams do important work, too. An example for that legal or licensing problems are often found during reviews at SUSE, one of KDE’s downstream partners. These are often fed back to KDE’s developers where the problems can be fixed and be made part of upstream. This doesn’t have to change at all, in fact, with a quicker deployment process, we’re actually able to ship these fixes quicker to users. Likewise, QA that currently happens downstream should actually shift more to upstream so fixes get integrated and deployed quicker.

One big problem that we are currently facing is the variety of software stacks our downstreams use. An example that often bites us is that Linux distributions are combining applications with different versions of Qt. This is not only problematic on desktop form-factors, but has been a significant problem on mobile as well. Running an application against the same version of Qt that developers developed or tested it against means fewer bugs due to a smaller matrix of software stacks, resulting in less user-visible bugs.

In short: We’d be better off if work happening downstream happens more upstream, anyway.

Upstream as software distributor

Software directly from its sourceSoftware directly from its source
So, what’s the idea? Let me explain what I have in mind. This is a bit of a radical idea, but given my above train of thoughts, it may well solve a whole range of problems that I’ve explained.

Linux distributors supply a base system, but most of the UI layers, so the user-visible parts come from downstream KDE (or other vendors, but let’s assume KDE for now). The user gets to run a stable base that boots a system that supports all his hardware and gets updated according to the user’s flavor, but the apps and relevant libraries come from upstream KDE, are maintained, tested and deployed from there. For many of the applications, the middle-man is cut out.

This leads to

  • vastly reduced packaging efforts of distros as apps are only packaged once, not once per distro.
  • much, much shorter delays until a bug fix reaches the user
  • stacks that are carefully put together by those that know the apps’ requirements best

Granted, for a large part of the user’s system that stays relatively static, the current way of using packaged software works just fine. What I’m talking about are the bits and pieces that the users relies on for her productivity, the apps that are fast moving, where fixes are more critical to the user’s productivity, or simply where the user wants to stay more up to date.

Containerization allows systemic improvements

In practice, this can be done by making containerized applications more easily available to the users. Discover, Plasma’s software center, can allow the user to install software directly supplied by KDE and allow to keep it up to date. Users can pick where to get software from, but distros can make smart choices for users as well. Leaner distros could even entirely rely on KDE (or other upstreams) shipping applications and fully concentrate on the base system and advancing that part.

Luckily, containerization technologies now allow us to rethink how we supply users with our software and provide opportunities to let native apps on Linux systems catch up with much shorter deployment cycles and less variety in the stack, resulting in higher quality software on our users’ systems.

Bienvenidos a la crónica matinal del segundo día de Akademy-es 2017 de Almería, una jornada un poco extraña para mi ya que solo estuve la mitad de ella, la vespertina. La razón es que por la mañana estuve en la Asamblea General de KDE e.V., del cual soy miembro desde hace poco. No obstante, mi pajaritos me han informado con solvencia de lo ocurrido. Espero no que notéis la diferencia.

Crónica matinal del segundo del día de Akademy-es 2017 de Almería


  • 10:00 – 11:00 Mi primera Aplicación KDE para Android – Albert Astals, desarrollador de KDE

Rompe el hielo Albert Astals, uno de los desarrolladores con más experiencia de la Comunidad KDE, que nos explica de forma práctica como crear una aplicación para el sistema dominante en los smartphone.

Concretamente, vemos como Albert creta un aplicación Qt para Android + PC usando QtQuick para la UI y KDE Frameworks.

Crónica matinal del segundo del día de Akademy-es 2017

  • 11:05 – 11:40 La importancia de la promoción: podcasts de KDE España – Ruben Gómez, coordinador de Podcasts de KDE España

Llega el momento de una charla centrada en la promoción de KDE España y el proyecto KDE. El gran comunicador Rubén nos cuenta la experiencia de la realización de los Podcast de KDE España, los cuales han sufrido un gran empuje desde que él se subió al equipo.

Además, mostró las estadísticas sobre las visitas y las  interacciones que están recibiendo los vídeo-podcast.

Aprovecho la ocasión para invitaros a seguirnos en los canales habituales:


  • 12:00 – 12:35 Modern C++ – Jesús Fernández, desarrollador de The Qt Company

Vuelven las charlas técnicas de la mano del nuevo miembro de KDE España, Jesús Fernández, que se estrena hablando del lenguaje de programación C++. En ella nos muestra un par de ejemplos que comenta detenidamente.



  • 12:40 – 13:25 Portátiles Slimbook y KDE – Alejandro López, Slimbook Team

Para cerrar la mañana se decidió parar con esta charla, y así coincidir con la gente de KDE e.V. en la comida. Entra en juego, Alejandro López, miembro del equipo de Slimbook, que nos habla de su gama de ordenadores compatibles 100% con Linux y de su producto nacido de la unión de los esfuerzos con el proyecto KDE, el famoso KDE Slimbook.

No obstante, el centro de su charla son las motivaciones de la empresa por introducirse en el apasionante y apenas explorado mundo de la unión de Hardware y Software Libre en un solo producto.

Recuerda: utiliza la etiqueta #akademyes cuando utilices twitter o facebook y hables de nuestro evento.

We’re releasing the second beta for Krita 3.2.0 today! These beta builds contain the following fixes, compared to the first 3.2.0 beta release. Keep in mind that this is a beta: you’re supposed to help the development team out by testing it, and reporting issues on bugs.kde.org.

  • There are still problems on Windows with the integration with the gmic-qt plugin, but several lockups have been fixed.
  • The smart patch tool merge was botched: this is fixed now.
  • It wasn’t possible anymore to move vector objects with the mouse (finger and tablet worked fine). This is fixed now.
  • Fixed the size and flow sliders
  • Fixes to saving jpg or png images without a transparency channel


The KDE download site has been updated to support https now.


Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.


(If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)

A snap image for the Ubuntu App Store will be available from the Ubuntu application store. When it is updated, you can also use the Krita Lime PPA to install Krita 3.2.0-beta.2 on Ubuntu and derivatives.


Source code


For all downloads:


The Linux appimage and the source tarball are signed. You can retrieve the public key over https here:
. The signatures are here.

Support Krita

Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.

Hey Community!

Long time no see, huh? Yes, I neglected my blog and as such didn't post anything since Akademy 2014... Interestingly this is the last one where my dear Paul Adams held a famous talk. Talk he is referring to in his latest piece. Since his blog aggregation to Planet KDE is broken, I thought it would be a good idea to relay it on my own blog to give it more exposure. It is reproduced below, if you want to read it in its original form, click through the title.

Paul, the mic is yours now!

Retired From KDE, by Paul Adams

Many of you reading this are probably already aware, long-time maintainer of glibc Roland McGrath has recently retired from maintaining that project. Inspired by his words, I wanted to say a few things about why I no longer contribute to KDE; a project I “retired” from some time ago now.

Recently two very good friends of mine, both long-term KDE contributors, inquired if I was going to be attending this year’s Akademy (the annual KDE conference). Neither were particularly surprised when I said I wasn’t.

I was surprised that they asked.

Getting Into KDE

My first experiences of KDE were many moons ago; sometime in the very early 00s I guess. I had installed Linux on an old machine and was not particularly enjoying the desktop experience.

There wasn’t a desktop.

I cannot remember which distro this was. It had come off some magazine’s cover CD. There was X. And the tiling window manager which allowed me to fill my screen with x-term. This, for a long time, was just how I got stuff done. Emacs, Mutt, Lynx and some weird terminal-based MP3 player were my jam.

Some time later I was reading another magazine (Linux Format?) and it had a review of a recent beta of KDE 2. The sources were included on the cover CD. KDE looked kinda nice. Less boxy and purple than the only other *nix desktop I had seen, CDE. Until I finished my undergraduate degree KDE was my go-to desktop.

Getting Deeper

For a while I had reverted to using a tiling window manager and a screenful of x-term. This was just a convenient way for me to get through my PhD and my day job.

During my PhD I was studying Free Software community productivity metrics. I was also working on research into software quality funded by the European Commission. KDE eV (the governance body1 for KDE) was also taking part in that project. At this time KDE was almost ready to release KDE 4. It was an exciting time to get involved.

So I installed whatever the Debian stable KDE desktop (3.1021933933923932) of the time and really enjoyed the experience. Having rediscovered my love for KDE and having met some of the active community, I dived in deeper.

KDE became high on my list of projects to study during my PhD. The community was going through major changes: not only was KDE 4 on its way in, but KDE SVN was on its way out.

Gitting Ready For Change

Around 2006 I discovered Ade de Groot’s tool for visualising contributions to SVN; it was part of the English Breakfast Network3. His version of this tool utilised Python’s SVN bindings to read the repo data. Git instinct told me this tool would work faster if it parsed SVN logs rather than read the repo data through a library. I turned out to be right and this was a formative moment in my career.

I created a generic SVN log parser for use by this visualisation tool and used the same parser for other purposes; mostly other visualisations and data plotting. The ultimate aim was to expose to the KDE community what we could learn about social interactions within the community from, arguably, its most important communication tool: the version control system.

KDE SVN was4 truly enormous. It was pretty much the largest SVN repo in the wild. One very large central repo which represented the entire body of KDE code/artefacts. Around this time the strains of using such a repo with such a huge (and growing) community were prompting discussion about distributed VCS.

These were remarkably mature and structured discussions. Git was, by no means, a foregone conclusion. Other distributed VCS were given headroom and this was the first (and, basically, last) time I played with Mercurial and Bazaar. The discussions were, for the most part, very technical. I raised my voice to talk about the potential social impacts of switching from SVN to distributed VCS. Any distributed VCS.

Joining KDE eV

I spoke at Akademy and other KDE events (including the KDE 4 launch at the Googleplex) about the research I was doing; either my PhD or the EC-funded stuff. I blogged. I dented5. My work was positively received and gearheads would actively reach out to me for more-detailed analysis of their corner of KDE.

I was encouraged to join KDE eV and I did. Given that I had made precisely 0 code contributions6 to KDE this, to me, felt like an achievement.

Since day one of my involvement, KDE eV had somewhat of an identity crisis. It was really not 100% clear what it did… but anyone who had been involved with KDE for more than 6 months was highly encouraged to join. Before long it had become bloated; lots of members contributing almost nothing and the few people wanting to do something not getting enough support to do it.

KDE has switched to Git and the social changes were a-happenin’. The KDE project was starting to lose its social cohesion. Post KDE 4.0-release blues, the switch to GIT and a lack of care from KDE eV all contributed here. Other things, too. No one thing started the KDE community’s cohesion degradation. But we felt it. We even went though a rebranding… KDE was not a desktop project, it had become a suite of projects and the desktop was just one of them.

KDE had evolved and I had not.

Cohesion Degredation?

One of the metrics I worked on during my PhD was a simple use of graph theory to measure how well-connected a community is. The contribution I made here was intriguing: as project get bigger they become less cohesive, but through careful community management, luck and clever structure, KDE avoided this.

The last time I properly attended Akademy (the KDE community conference) was back in 2014. I’d been frustrated for some time with my inability to drive home the message that the switch to GIT had o be managed properly. I’d been frustrated that nobody seemed to have noticed that my warnings were coming true.

So I gave a talk that year.

Deep down, I knew this was my last public outing on behalf of KDE. It was. After my talk a lot of people came up to discuss the mic I had just dropped. But as the days and weeks passed after the event, the message disappeared. And so did I.

So Why Are You Telling Us This Now?

This year’s KDE conference starts tomorrow. Two of my all-time best buddy KDE community members reached out to see if I was turning up.

They knew I wasn’t.

While we briefly reminisced by email, one of them pointed out that my talk from 2014 had recently come up in conversation on a KDE mailing list. That, 3 years later, the talk was being used as part of a great discussion about change in the project.

I’m really not sure what my emotion about that was. But, I did not feel compelled to join the discussion. I did not feel a need to remind people about what I was trying to achieve all that time ago. Nope. Instead, I went and pushed some changes to a core plan I had been working on for Habitat, the new home for my free time.

The Thanks

To all my friends in KDE:

Enjoy Akademy. Enjoy the opportunity to do some navel gazing. Enjoy the food, the drinks, the sun. Hack. Break shit and put it back together again. Remind yourselves of why KDE is special. Remind yourselves of why it is important. Very important.

I thank you all for the time we spent together.

We were all part of the solution.


  1. Countdown to flamewar… 3… 2… 1… I know many will object to me calling KDE eV a “governance body” but, no matter how you cut it, that is what it is. At least it should be, imo. 

  2. There were approximately this number of KDE 3 releases. 

  3. Is the EBN still a thing? 

  4. Is? 

  5. Is identi.ca still a thing? 

  6. Thanks to the EBN, I did actually fix a spelling error in a comment in a .h file for Marble7

  7. This makes me a true C++ h4xX0r, right? 

  • otherwise throw away no feature branches needed when:
  • focused team
  • effort predictability

experiments and collaboration implies quantum effect branches

in any case lifetime upper bound

July 21, 2017

I planned on writing about the Present extension this week, but I’ll postpone this since I’m currently strongly absorbed into finding the last rough edges of a first patch I can show off. I then hope to get some feedback on this from other developers in the xorg-devel mailing list.

Another reason is that I stalled my work on the Present extension for now and try to get first my Xwayland code working. My mentor Daniel recommended that to me since the approach I pursued in my work on Present might be more difficult than I first assessed. At least it is something similar to what other way more experienced developers than myself tried in the past and weren’t able to do according to Daniel. My idea was to make Present flip per CRTC only, but this would clash with Pixmaps being linked to the whole screen only. There are no Pixmaps only for CRTCs in X.

On the other hand when accepting the restriction of only being able to flip one window at a time my code already works quite good. The flipping is smooth and at least in a short test also improved the frame rate. But the main problem I had and still to some degree have, is that stopping the flipping can fail. The reason seems to be that the Present extension sets always the Screen Pixmap on flips. But when I test my work with KWin, it drives Xwayland in rootless mode, i.e. without a Screen Pixmap and only the Window Pixmaps. I’m currently looking into how to circumvent this in Xwayland. I think it’s possible, but I need to look very carefully on how to change the process in order to not forget necessary cleanups on the flipped Pixmaps. I hope though that I’m able to solve these issues already this weekend and then get some feedback on the xorg-devel mailing list.

As always you can find my latest work on my working branch on GitHub.

KDE Chartered Flight to Almería

We have travelled from across the globe to meet for our annual gathering where we plan and discuss the next year's activities creating free software to share with the world. Almería is in the south east of Spain, a country which has long been a supporter of free software and collaboration with its creators. The sun here is hot but the water is also warm for those who make it to the beach to discuss their work with a pina colada and a swim. Over the last year KDE has run conferences in Brazil, India, Spain, Germany and sprints in Randa in Switzerland, Krita in the Netherlands, Marble in Germany, GSoC in the US, WikiToLearn in India, Plasma in Germany, Kontact in France, and sent representatives to OSCAL in Albania, FOSSASIA in Singapore, FUDCON in Cambodia, HKOSCon in Hong Kong and more.

Tapas y Sangria

Today we meet from around the globe, KDE contributors have flown in from Taiwan, US, all over Europe and British Isles, India, Brazil, Canada.

We have completed Akademy España, talks in Spanish to the community.

We also met for the formality of KDE e.V. Annual General Meeting.

The Community Working Group reviewed issues they had to deal with and were pleased there were fewer firefighting issues than in previous years and they could concentrate on gardening community.

We are KDE

Our outgoing treasurer Marta reported on the year's finances which were pleasingly balanced and with ample reserves. The Financial Working Group reported how they had supported this and that their main task is to support the incoming new treasurer.

The Sysadmin Working Group reported on the pleasing developments retiring old machines, old software such as Drupal 6 and old operating systems. They are moving towards Ansible for system deployment and were pleased at the new multi-platform CI system which is now running.

We heard from the Advisory Board Working Group who now have regular meetings with representatives from supporting companies and large deployments of KDE software.

The KDE Free Qt Foundation controls the licencing of Qt with representatives from both KDE and Qt company. In the last year they have concluded the relicensing of all Qt parts as Free Software. All parts of Qt are available under the GPLv3 or under a compatible license. Most parts are also available under the LGPLv3 and under the GPLv2. The last remaining code to be relicensed was the Qt Quick Compiler. This is now deprecated and replaced with an open source solution since the release of Qt 5.9.

Your new KDE e.V. board

Finally we voted on replacement board members for the three who's terms came to an end. Marta the treasurer did not renew her term. Holding one of the most important but least thanked tasks in KDE we owe her much gratitude for keeping out books balanced and our payments prompt. Lydia Pintcher and Aleix Pol i Gonzàlez both stood for the board again and were re-elected for another three years. And long term KDE developer Eike Hein was elected as a new board member, hoping to bring in more representation to the community from Korea where he lives. We thanked the outgoing and new board members with the traditional thanks of a fancy dinner.

Tonight we drink sangria and wine under the stars at a welcome party meeting old friends and new, eating tapas of salmorejo, croquetas, tortillas and rice, looking forward to the week ahead.

Continuamos con la tercera temporada de los vídeo podcast de la Comunidad KDE española. En esta ocasión, y dado que los integrantes de KDE España se encuentran juntos en Almería, Akademy-es y Akademy serán protagonistas del nuevo podcast de KDE España. Así que, si nada lo impide, el próximo lunes 24 de julio a una hora por determinar, pero mañanera,  nos encontremos en directo y, con toda probabilidad, con un formato novedoso.

Akademy-es y Akademy 2017 serán protagonistas del nuevo podcast de KDE España

Akademy-es y Akademy 2017 serán protagonistas del nuevo podcast de KDE EspañaYa se habrá terminado Akademy-es y la parte de las charlas de Akademy, momento en el cual los integrantes del podcast de KDE España se reunirán en un lugar con buena conexión a la red para tratar como han ido estos eventos, explicar sus sensaciones y a contaros de primera mano las novedades que han surgido en ellos.

También será el momento para comentar los cambios que están surgiendo dentro de la misma asociación de KDE España, que seguro que os gustarán y animarán a formar parte de ella.


Así que. si no ocurre algún problema, el  próximo 24 de julio os invito a escucharnos (y vernos) en directo hablar sobre temas relaciones con KDE y el Software Libre en general.

Para poder disfrutar del podcast en directo seguiremos utilizando los servicios de acontecimiento en vivo de Youtube  y contestaremos, si podemos, vuestras preguntas en directo. Por cierto, este podcast será el séptimo de la tercera temporada.

¡Os esperamos el lunes 24 de julio a las 18:30!

Los podcast de KDE España

Ayúdanos a decidir el temaEn un afán de acercarnos más a todos los simpatizantes de KDE hace un tiempo que empezamos a realizar podcast. En ellos varios miembros de la Comunidad KDE de España nos reunimos para hablar un poco de los diversos proyectos.

Hemos hablado de muchos temas como por ejemplo Akademy, KDE Connect, Plasma Mobile, etc.

Podéis seguirnos en  el canal de Youtube de KDE España o en Ivoox, donde estamos subiendo poco a poco los audios emitidos. Esperamos que os gusten.

It's with all the joy in my heart that I share with you this amazing notice: AtCore was officially moved today to KDE Extragear by my favorite sysadmin Ben Cooksley after more than a month on KDE Review. This is the first huge milestone that we achieve on this 11 months of team work made [...]

July 20, 2017

Llegó el gran día para los KDEeros españoles. Esta es la crónica primer día de Akademy-es 2017 de Almería. Espero que sirva para que los que no habéis podido venir os hagáis una idea de cómo se ha desarrollado el día.

Crónica primer día de Akademy-es 2017 de Almería.

Mi día comienza saliendo de casa a las 6 de la mañana y tras cinco horas de coche llegué a Almería. Fue muy sencillo encontrar el alojamiento recomendado y registrarme. Lo cierto es que la Residencia Civitas me sorprendió por su limpieza y su aspecto impoluto… cierto es que apenas tiene un año de funcionamiento pero no se le puede pedir más a una Residendencia de Estudiantes.

Tras llegar a la habitación, deshacer la maleta y cerrar unos asuntos, bajé al vestíbulo donde empecé a encontrarme con miembros de KDE España y otros desarrolladores de KDE Internacional. Saludos y alegría. No soy muy efusivo pero dentro de mi corazón mi regocijo es enorme.

Es el momento de ir a comer a la Universidad. Comida en la cantina de la Facultad abundante y buena. Empiezan las conversaciones interesantes sobre el software libre y la vida en general.

Ahora nos vamos al aula de las charlas para acabar de prepararla. Enchufes, wifi, mesas, etc. Es el momento que aprovecha Slimbook para montar su mesa de promoción y mostrar al mundo sus productos como KDE Slimbook o Excalibur.

  • 16:00 – 16:05 Ceremonia de apertura – Albert Astals, desarrollador de KDE

La persona que da inicio a esta primera jornada es el gran Albert Astals, ex-presidente de KDE España y desarrollador incansable de la Comunidad KDE. Con una pocas palabras da las gracias a los principales agentes que han hecho posible la realización de Akademy-es 2017Universidad de Almería (UAL)UNIA (Universitarios Informáticos de Almería) y HackLab Almería. Y, por supuesto, a Opentia por patrocinar el evento.

  • 16:10 – 16:45 Desarrollando Software Libre sin ser informático – Baltasar Ortega, editor de KDE Blog

La primera charla de la tarde la realiza un servidor, Baltasar Ortega editor de este blog, que intenta hacer una charla motivadora animando a que los asistentes al evento colaboren con el Software Libre y que si ya lo hacen animen a sus allegados a que también lo hagan, aunque sean simples usuarios. Ya que en realidad todo el mundo puede ser desarrollador de KDE aunque no sepa escribir una línea de código.

Crónica primer día de Akademy-es 2017 de Almería.


  • 16:50 – 17:25 Aplicaciones convergentes con QtQuick y Kirigami – Aleix Pol, Vicepresidente de KDE eV

Toca una charla una charla un poco más técnica con QtQuick y Kirigami de la mano de Aleix Pol donde nos pone los antecedentes de estas tecnologías y su relación con el proyecto KDE y nos explica un poco la estructura de Discover, una aplicación convergente.

Nos muestra otras aplicaciones como Subsurface, Kalgebra y Minuet, antes de explicar los componentes interesantes y explicar 4 ejemplos.


  • 17:30 – 18:05 Empaquetando KDE para openSUSE y SUSE Linux Enterprise – Antonio Larrosa, Presidente de KDE España

Llega el turno del desarrolladore de KDE más veterano que nos explica cómo funciona el empaquetado de los paquetes de KDE para las dos distribuciones de SUSE. Todo ello de forma prácticamente automática y online.

Como siempre, es sorprendente la forma de trabajo que tiene SUSE.


  • Descanso

Momento de tomar un respiro y reponer fuerzas. Café, zumo, bocadillos y dulces cortesía de KDE España. Momento de charlar de muchos temas de Software Libre.



  • 18:35 – 18:50 Para que sirve KDE España – José Millán, Tesorero de KDE España

Sale a la palestra el tesorero para explicar qué es y que no es la asociación KDE España. Una interesante charla de obligada realización todos los años. Uno de los objetivos de Akademy-es es aumentar el número de socios.

En esta presentación se anuncia la nueva forma de ser socio de KDE España, a la cual dedicaré una entrada especial.


  • 18:55 – 19:30 Buscando nuevos horizontes para KDE – Agustin Benito, ex-Tesorerode KDE eV

Finalizamos la jornada con el gran ideólogo de KDE Agustín Benito (@toscalix) que antes de empezar su charla nos presenta una charla donde nos muestra una pantalla táctil montada sobre una Raspberry Pi  con una distribución GNU/Linux y que sirve para controlar todos los parámetros de nuestro automóvil.

A continuación empieza su charla donde realiza una visión reflexiva sobre el el momento actual de KDE y hacia donde cree que debe moverse la Comunidad KDE que no es más que al mundo de la automoción. Una más que interesante charla.

Al finalizar toca realizar la Asamblea Anual de KDE España, la reunión donde los socios y tratan asuntos referidos al funcionamiento de la asociación.

Una vez concluido el cónclave queda recoger trastos e ir a la Residencia, y tras descansar unos minutos, reunirnos de nuevo para ir de cena. El colofón perfecto a un día perfecto. Mañana más.

Recuerda: utiliza la etiqueta #akademyes cuando utilices twitter o facebook y hables de nuestro evento.

This release includes all the feature-enhancements the Linux version has received (frameworks announcements for 5.36.0)

– Actually working spell-checking.
– Possibility to switch interface language.

EDIT: Adding an extra fall-back UI language does not wok properly yet.

Kate in SweedishKate in Sweedish

Grab it now at download.kde.org:  Kate-setup-17.04.3-KF5.36-32bit or Kate-setup-17.04.3-KF5.36-64bit

When I released Brooklyn v0.1 complaints arose from the fact that it is written in Java.
A lot of criticisms come from users that probably wrote Java code when it was born.
The language is constantly changing and I decided to use Java 8 as the primary language for Brooklyn.
I'm writing this blog post because while I was learning new features I realized that there is an enormous difference between studying something and applying what you have studied in a practical scenario.
I'll keep writing posts like that, and I want to write much more if I receive a good feedback!

Avoid null pointer exceptions
Imagine that you've a Bot interface with a method sendMessage and three classes that implements that: IrcBot, TelegramBot and RocketChatBot.
sendMessage returns a string which contains the messageId returned from the bot; the main problem is that there are bots like IrcBot which can send messages to IRC, but the protocol doesn't support messages identification.

What should you do? The first thing you can come to your mind is to return a null:

public interface Bot {
String sendMessage(...);

public final class TelegramBot implements Bot {
public String sendMessage(...) {
// Message is sent here

return msgId;

public final class IrcBot implements Bot {
public String sendMessage(...) {
// Message is sent here

return null;
The main problem is that if your code somewhere stores the string and use it without checking if it is null, the application will crash because of a NullPointerException.

A good solution is to use the class Optional. Let's see how to use it:
public interface Bot {
Optional<String> sendMessage(...);

public final class TelegramBot implements Bot {
public String sendMessage(...) {
// Message is sent here

return Optional.of(msgId);

public final class IrcBot implements Bot {
public String sendMessage(...) {
// Message is sent here

return Optional.empty();
Imagine now that you've sent a message with a Bot bot = new ...(); and you want to use the result of Optional<String> result = bot.sendMessage(...).
First of all, you can check if it is empty or not, and then you can do something (in this case, print the message id):

if(result.isPresent()) {
String msgId = result.get();
You can also rewrite it with Lambda Expressions:
result.ifPresent(msgId -> System.out.println(msgId));
or more simply with Method References:

There are cases when you don't know if a function returns a null or not.
Let's imagine that you've a static method from a library x called getFile() which returns a File object or null.
Instead of checking if it is null, you can simply write Optional<File> file = Optional.ofNullable(x.getFile());which is the equivalent of:

Optional<File> file;
File fileNull = x.getFile();
if(null == fileNull)
file = Optional.empty();
file = Optional.of(fileNull);

Time to fly off to the sun to meet KDE friends old and new and plan out the next year of freedom fighting. See you in Almería!


Facebooktwittergoogle_pluslinkedinby feather

We are happy to announce the release of Qt Creator 4.4 Beta!



This version of Qt Creator features optional inline annotations for warnings and errors from the Clang code model and for bookmark comments (Options > Text Editor > Display > Display annotation behind lines). This way, you can easily see the details of issues while you type, without the need to hover your mouse over underlined text or the marker on the left side.


When you rename a symbol, you are now offered to also rename files with the same name. Just trigger the renaming and check “Rename N files” (where “N” will be the number of files with the same base name) in the search results panel before pressing the actual “Replace” button.

If you have the Clang code model enabled, this is now also used for the highlighting of the identifier at the text cursor, which was previously still using the built-in model in any case.

There have been many bug fixes as well. C++ and Qt keywords are no longer wrongly considered keywords in C files, the function signature hint will now work when completing constructors with the Clang code model, and many more.


We were pretty busy fixing issues already in the 4.3 line of Qt Creator, but there are some improvements in 4.4 as well. We added a filter to the CMake variables setting in build configurations, fixed that headers from the top level directory were not shown in the project tree when using server-mode and improved the handling of CMAKE_RUNTIME_OUTPUT_DIRECTORY in CMake project files.

Other changes

We removed the non-maintained support for Window CE, and changed the ClearCase integration to be disabled by default.

This is just a small selection of the changes and improvements done in 4.4. Please have a look at our change log for a more detailed overview.

Known Issues

QML Profiler can currently get into invalid state. Stopping the application before stopping profiling currently does not work.

Get Qt Creator 4.4 Beta

The opensource version is available on the Qt download page, and you find commercially licensed packages on the Qt Account Portal. Please post issues in our bug tracker. You can also find us on IRC on #qt-creator on chat.freenode.net, and on the Qt Creator mailing list.

The post Qt Creator 4.4 Beta released appeared first on Qt Blog.

I completed the Oware two player mode as described in my previous blog post GSoC-First month analysis. This month was the time for the single player mode. So well it started well, I implemented the alpha beta pruning for the AI mode.

The levels are structured in the following way:

  1. For the initial levels the AI is random which sows randomly from its houses. But if the computer gets in a bad position or is losing badly then it switches to AI mode. A maxDiff is maintained for each level, for example level 1 has maxDiff = 20, level 2 has maxDiff = 15 and so on. So as soon as the computer/AI is behind the player by maxDiff it switches to AI mode.
  2. For the last levels there is no random selection so basically maxDiff = 0.

I also had been working on the animation of seeds which involves movement of the seeds from one house to another. It still has some issues left involving the animation being triggered at each step.

There are also some changes in my GSoC plan. I thought of working on computer activity after oware earlier when I made my proposal but with discussions with my mentors we came to a conclusion that musical activities are more important for a child. So I would be working on musical activities now which includes play piano and note names activity which were started in the branch Play piano and were earlier to be done in my last month. My aim would be to complete both these activities.

I planned to go to Akademy this week and meet everyone but well my visa got refused :( I will try to be a part next year and I hope I get the chance of meeting everyone (especially my mentors soon). I will cover more about the musical activities and my progress in my next blog post :)

July 19, 2017

I’m currently in my final preparations for this year’s Akademy.

For people unaware of this conference, it is the annual conference of KDE contributors.

We tend to have a few dozen of high quality talks on various topics ranging from art and community building, to hard-core Qt and C++ talks.

This year, I’m going to have two talks. One on (obviously :) ) functional programming in C++, and one on C++17 and 20. The later one will be a bit self-serving because I’d like us to raise the compiler requirements for our software so that we could enjoy working in KDE even more.

The only thing more important than talks is the period after where the different teams within KDE meet-up to discuss the future plans. While we do it all the time on IRC and on the mailing lists, having face-to-face meetings is irreplaceable.

If you are near Almeria, join us – the conference is free for attendance!

Going to Akademy


Hi everyone!
As the title of this blog post suggests, the first evaluation has been successfully passed, the project accomplishing all the proposed goals. Thus, let me present you the progress I’ve done for the first evaluation.

  • The very first thing I’ve took care was allowing multiple-instrument visualization framework, by modifying the old core architecture of Minuet. Instead of the one and only keyboard instrument, Minuet is now providing an instrument tab bar, enabling the end user select the desired instrument. The tab bar is currently loading the instrument within the first tab as default. After I’ve discussed with my mentor, Sandro, I decided to keep the piano keyboard as the default instrument contained by the first tab. In order to keep all the functionalities available and a simple architecture at the same time, I’ve created an InstrumentView wrapper above all the instruments. Its methods are called by the core ExerciseView, calling in turn the methods that each instrument should implement.


  • After changing the Minuet’s core in order to provide a multi-instrument framework, I started refactoring the piano keyboard view as a separate plug-in. Basically, for Minuet, a plug-in is nothing more than a bunch of QML files and a simple JSON file parsed in order to learn about the QML files’ location and load them dynamically in the instrument tab bar.


The next goal was to install each instrument separately as a plug-in, besides all other Minuet’s plug-ins. Like any other KDE application, Minuet, keeps its data files into /usr/share/ file-system directory. Thus, this was the place where our plug-ins had to be installed; actually, the exact path is /usr/share/minuet/plugins/. Installing a plug-in is simply done by using a CMakeLists.txt file telling the build system where the plug-in files should be installed.

Plug-ins are loaded as follows: firstly Minuet searches for plug-ins location and if the search succeeds, it will iterate through each instrument’s JSON file, building a QJsonArray containing the plugin name and path. This QJsonArray is passed to the InstrumentView, setting the contents of the Instrument Tab Bar. Having all the tabs ready, the TabBar will just wait for a tab to be selected and a QML file to be loaded.

  • Having the multiple instruments framework and piano plug-in ready, the next step was to test and analyze the code for possible technical issues or bugs. Also, a general clean-up was required before submitting the code for the review and first Google Summer of Code evaluation.


These are the achievements I’ve met for the first evaluation. Let’s discuss now about the current progress for the next evaluation:

  • I wrote a proper and comprehensive documentation for the piano plug-in, enabling anyone to create his/her own instruments plug-ins and loading them dynamically into Minuet.
  • I started implementing a new instrument from scratch. As I am very passionate about guitar, I chose to integrate it into Minuet’s instruments suite. Thus, I have already designed the visuals for the Guitar plug-in and added it into Minuet’s instrument tab bar. Now, I need to link the GUI to the core, work on the guitar’s specifics and make the plug-in fully functional.


In conclusion, GSoC proves to be a great experience thus far, being a pleasure to work on a project focused mainly on a subject I’m in love with: music. For further cool news, stay tuned!


A lot of implementation changes were introduced

  • Selection highlights depends upon the items selected in the model.
    • Previously, the selection higlights toggled when the SelectionButton for an image was clicked
    • Now the higlighted images are shown according to the items selected and stored in the selection model

  • Completely removed baloo dependency

  • For “By Folder” filter KIO based model is used for folder representation of images.
    • It shows the mixed images and folders in the AlbumView.
    • It shows the images in hierarchical structure, as they are represented in the memory. Just like a file manager would represent, but just the images and folders.

      Folder Structure

  • Adds a new ImageListModel
    • This model would just store the image list irrespective of whether they are from ImageLocationModel or ImageTimeModel.
    • This made the representation of images in the GridView and the ImageViewer a lot more easier

  • Better implementation of ImageViewer done by Marco Martin
    • Better animations for ImageViewer to appear and disappear.
    • Pinch zoom for the single Image appearing in the ImageViewer.
    • Zoom animations for the images in ImageViewer. Zoom on double clicking the image as well as on Ctrl + wheel action

      Normal Image Zero Zoom

      Zoom on Double Click Double Click Zoom

      Ctrl + wheel Zoom Ctrl + Wheel Zoom

  • Automatic updation of the currentIndex for the GridView if the index changes in the ImageViewer.

  • Makes the thumbnailer code common to all the models.
    • Faster loading of thumbnails for the GridView.

  • Totally removed the old code base qml implementation.

  • Adds KDirNotify and KDirWatch to support live updates of the data in the time and location collections as well.
    • We don’t need to add KDirNotify and KDirWatch to the ImageFolderModel since it subclasses KDirModel which already takes care of the changes.
    • KDirWatch uses the concept of singleton object ie we can use just a single instance of the KDirWatch class for the entire application.

  • Makes the enums common for all the models.

  • i18n’z all the text elements.

  • Creates a different SortModel for the ImageViewer to apply sort as well as the filter to show just the images.

  • Adds contextualActions to the AlbumView.
    • For now three actions are added Select all, Deselect all and Delete selections.
    • These actions can just be applied on the images and not on the collections or folders.

  • Selectively loads desktop and mobile user interface depending upon whether the environment variable QT_QUICK_CONTROLS_MOBILE is set or not.

    • There is just single difference between mobile UI and desktop UI, that is of the contextualActions. For desktop version these appear on the toolbar and for mobile version these appear in the contextDrawer.
    • Rest of the changes are handled brilliantly by the Kirigami.

      Desktop UI Desktop UI

      Mobile UI Mobile UI

  • Adds a selection mode for mobiles that is activated on pressAndHold.

    On PressAndHold Tap and Hold

  • Opens a specific image via the commandline.
    • That allows us to open the image from the file manager also.
    • It takes you directly to the single image in the ImageViewer
    • It also pushes the intermediate folders into the pageStack(that contains AlbumView) starting from the standard Pictures location to the folder containing the image, for the “By Folder” filter.
    • If the image is not in the Pictures location then it just pushes the folder into the pageStack(that contains AlbumView).
    • Though this is not perfect yet. The problem is that the SortModel(QSortFilterProxyModel) in the ImageViewer is populating in pieces that is first when the sourceModel for the model in ImageViewer is set to specific ImageFolderModel with empty data (I think) and then again the rowsInserted signal is emitted and the model is populated again and thus making the rowCount to double of the actual number of images, which then makes the currentIndex in the ImageViewer invalid(-1) at the beginning and hence the navigation starts from the first image in the list instead of the selected image. Searching for the alternatives :)

  • PS: The background shown in the application is theme dependent. This is Breeze-dark theme


In my last post, I talked about adding a grid layout to the activity. The inspiration of this layout was to remove the trial and error method of selecting (x,y) positions of a node and to implement a more efficient method of positioning the nodes. Along with that, the distance between two generations and nodes could also be maintained in a homogeneous manner, keeping the layout similar throughout the activity.

As it also turned out, the grid layout along with knowing the width and height of the node also helped in accurately positioning the edges, the effect of which will be shown in a few before-after screenshots later in this post


Vertically, the screen is divided into three equal parts (representing three generations), represented as:

readonly property real gen_1: 0.10
readonly property real gen_2: 0.40
readonly property real gen_3: 0.70

Here, gen_1, gen_2 and gen_3 represent 1st, 2nd and 3rd generation.

Horizontally, the area was originally divided into three parts:

readonly property real left: 0.2
readonly property real center: 0.4
readonly property real right: 0.6


Aside from this, we also divided the horizontal area into four other slots, which will be necessary as it turned out later:

readonly property real left_1: 0.1
readonly property real left_2: 0.3
readonly property real right_1: 0.5
readonly property real right_2: 0.7

The nodes

The arrangement of the nodes are very simple, in which we are avoiding the problem of arranging the nodes via trial and error of the (x,y) position. The x-coordinate can be determined by selecting the best among left, right and center or among left_x or right_x (where x = 1, 2) as mentioned above and the y-coordinate can be determined via selecting the best among gen_1, gen_2 or gen_3, depending on the generation of the node.

As an example, for level 11, we define the nodePositions as follow:

nodePositions: [
        [center, gen_1],
        [left, gen_2],
        [right, gen_2],
        [left, gen_3]

As we can see from the level, it can be seen that it is very intuitive to determine the node positions for a given level, once we know the type of the node.

The edges

The start-end position of the edges can also be determined via the properties mentioned above along with the nodeWidth and nodeHeight properties mentioned in the previous blog post. For level 11, we calculate the edge positions as:

edgeList: [
        [center + nodeWidth / 2, gen_1 + nodeHeight, center + nodeWidth / 2, gen_2 + nodeHeight / 2],
        [rightXEdge(left), nodeMidPointY(gen_2), right, nodeMidPointY(gen_2)],
        [left + nodeWidth / 2, gen_2 + nodeHeight, left + nodeWidth / 2, gen_3]

As a result of these, level 11 turned out to be like this:


How it all turned up

The layout has come a long way since it was started from the beginning of the second phase of GSoC, and here are the before and after screenshots of the family activity

level_18_before Initial layout of level 18

level_18_after Current layout of level 18

level_6_before Initial layout of level 6

level_6_after Current layout of level 6

What’s Next

I have started working on the extension of the Family activity, the goal of which is: given a relation, the user will have to find the pair that demonstrate the given relation. I will be documenting the progress of the activity once that is near completion, hopefully by the end of this week.

When using Qt’s model/view framework, filtering has always been very easy with QSortFilterProxyModel. To filter a list using text typed by the user in a line-edit, you have certainly been applying the standard recipe:

  1. instantiate the proxy;
  2. insert it between view and source model;
  3. connect the lineedit’s textChanged signal to the proxy’s setFilterFixedString slot; done!

But what if the model is a tree rather than a flat list?

Let’s use the tree below as an example. As you can …

The post New in Qt 5.10: recursive filtering for QSortFilterProxyModel appeared first on KDAB.

July 18, 2017

In the past there were two versions of LabPlot. The first one was based on Qt4 and KDE4 libraries. The second one uses Qt 5 and KDE frameworks 5. The development was done mainly in the Qt4-based branch which was merged from time to time to the Qt5/frameworks branch where the porting to Qt5/frameworks, if required, was done after the merge. Clearly, this caused a lot of additional work, was very time consuming sometimes and distracted us too often from the actual development – the development mostly done in our very limited spare time.

After long internal discussions we decided to stop developing and releasing the Qt4-version of LabPlot. It should be an exception nowadays to find a distribution without a reasonable support for Qt5 and KDE frameworks. So, starting from the next release, LabPlot 2.5, there will only be the Qt5/kf5-based release. We still can decide to provide fixes to the Qt4-based version, but there definitely won’t be any new features for this release anymore.

Working on one release only will allow us to concentrate more on the application itself and to increase the development speed. Our master branch is now on Qt5/frameworks since couple of weeks already with a lot of great new stuff being developed for the next release.

Having mentioned the next release, couple of words more about this. We plan to release closer to the end of this year. A lot of new features are already developed for the next release. Among them we want to mention the import of data from SQL databases as well as the import of Origin’s project files. Data fitting has got a lot of attention recently and the next release will allow the user to do more advanced fitting and to obtain much better representation of the results of the fitting procedure. Also, we improved a lot the user experience – the creation of multiple plots and data curves as well as performing of data analisis can be carried out more comfortable now and we’ll improve more in this direction soon. More on the new features will come in the next couple of blogs.

LabPlot’s GSoC2017 project makes also good progress and if everything goes well and as expected, the next release of LabPlot will provide support for live data coming from usual files, pipes, sockets and serial port.

Still, a lot of polishment has to be done until the release. Everybody who is interested in testing the new features, please don’t hesitate to build the current version of LabPlot from sources and to provide some feedback!


TIL the Rust compiler panics. A lot. Okay, it wasn't today, it was last week. Still. At this point I feel bad because I feel like I'm constantly coming out with something bad to say about Rust. I swear, I love the language. So I'm just going to point it out and move on: libsyntax panics on a lot of lexing and parsing errors. There. Moving on...

I have to admit, I spent too much time thinking of something interesting and engaging to write in this blog post but unfortunately it's just going to be a small progress report. You know the famous saying, a gif is worth a thousand words...


In my last post I showed highlighting done for declarations, but uses were not highlighted. Lo and behold...

Video should appear here; if it doesn't click here

This also means that go-to-declaration works as well. You might notice the uses aren't highlighted the same color as the declarations. That's a mistake on my part and I'm working to fix that.


As I've said before, KDevelop does a lot of things out-of-the-box if it has the Declaration-Use chain for a project. Renaming declarations is one of them.

Video should appear here; if it doesn't click here

Very basic code completion

In the spirit of short recordings, here's another one.

Video should appear here; if it doesn't click here

(yes, the cursor is slightly off in all of these; blame the recording software)
(((also if the videos aren't loading, you can view them here, here and here)))

Up next

Some more interesting things for code completion are coming up. Also, the Rust compiler has amazing error messages and I'm currently looking into getting the diagnostics out of libsyntax and show them in KDevelop. I'm looking into parsing imported modules as well, starting with libstd. All exciting stuff.

I'll also be speaking at KDE's Akademy this weekend, so if you're there, please feel free to drop by and say hi. I won't bite. :)

I'm going to Akademy

There's less than a week until the beginning of Akademy 2017 (if you still haven’t registered, do so now) and this is what you can expect from your first day at the event:

Keynotes and Master Talks

Akademy opens on Saturday, July 22 at 10 am with Robert Kaye, the brains behind Musicbrainz. We talked with Robert a few days ago, and he will tell us all about his projects and how he managed to marry FLOSS activism with the pragmatism of having to make money in order to keep them alive.

Sebastian Kügler will follow with an overview of the most important things that happened over the last year in the development of Plasma. He will talk about current features, future plans and goals, what to expect on your desktop over the next year, and how to help and get involved.

Meanwhile, in the next room, Jos van den Oever will examine Calligra and its native support for ODF. He'll look at a number of areas of ODF and see how well they are supported compared to other office suites.

At 11:50, Mirko Boehm will review the governance norms applied in FSFE, KDE and Wikimedia in his talk Why we Fight. He will examine how the norms developed over time and how current debates reflect their evolution.

Kdenlive, KDE's video editor, now comes with a new, re-vamped user interface.

At the same time, Volker Krause will present the UserFeedback framework, which provides ways to engage users from inside the application itself, including the collection of system or usage statistics, as well as asking an interested set of users that match a specific set of criteria to participate in an online survey.

Continuing on with a similar topic, at 12:30 Aleix Pol will talk about the challenge of developing for users employing bundled systems. We'll see what impact shortening the path between the development and users being able to run the software will have.

At the same time, Emma Gospodinova will tell us how she plans to add support for Rust, the promisingly popular programming language, to KDevelop during her Google Summer of Code project. Emma plans to include standard features any IDE should support for a language, such as semantic highlighting, code completion, refactoring, debugging and project management.

From there, we will move onto the light entertainment, which is movies. Or more like movie-editing. In Kdenlive, rewriting the timeline, Jean-Baptiste Mardelle will show us the new, polished Kdenlive 17.08, which now uses QML for many parts of the UI.

On a more technical note, Ivan Čukić will talk about how functional programming can improve our day-to-day work, make our code safer, cleaner and more correct.

Lightning Talks

After lunch, at 15:30, we'll have a bunch of lightning talks. The first one will be about Mycroft, the Alexa-like AI, and Aditya Mehra will explain how you can turn it into a Plasma widget and really enhance your life by having something you can boss about.

Volker Krause will then take the stage and tell us all about KF5::SyntaxHighlighting, a syntax highlighting engine that was originally tied to Kate, but can now be used anywhere.

Then Albert Astals Cid is up, and he will explain the work being carried out on Clazy, a compiler plugin which allows Clang to understand Qt semantics.

Marco Martin will then have ten minutes to explain how the feedback generated from the design and implementation of applications significantly improved the quality of Kirigami, KDE's user interface framework for developing applications that work both on mobile and desktop computers.

Finally, Vasudha Mathur will talk about Ruqola, the first generic chat application based on Rocket.Chat. Ruqola is a Qt/QML/C++ app and provides multi-platform portability. Ruqola will currently run on both desktop and mobile (Android) platforms.

... Back to Regular Talks

At 16:30, Sandro Andrade will be talking about preliminary implementation of a modular and flexible framework for building Qt mobile applications. He will also explain how you can use code generators and a plugin-based architecture to automate the implementation of recurrent tasks.

Babe allows you to add music from multiple sources, including YouTube.

At the same time and next door, Camilo Higuita will be introducing Babe, a contextual multimedia desktop app. Babe uses online resources and AI to find relationships between the music metadata and its context in order to generate personalized queries and suggestions.

Lydia Pintscher and the rest of the KDE e.V. Board will then sit down for an Ask Us Anything session with the audience at 17:10. If you want to find out what the board really gets up to and hear the plans for KDE as a community moving forward, here's your chance.

Meanwhile, Dmitri Popov will be teaching you how to take your digiKam skills to the next level by mastering its advanced functionality. Dmitri's talk will introduce several useful features and tools, such as filtering, batch processing, and curve presets.

At 17:55, John Samuel will be talking about Wikidata and how it can play an important role for the visibility of KDE applications. He will show how developers can build tools to integrate their applications with Wikidata to present an up-to-date view of their applications and their cool features.

At the same time, Arnav Dhamija will introduce you to the KIO (KDE Input Output) library. KIO is what allows your KDE apps to access data from a number of different protocols, such as local file systems, ssh, https, samba shares, ftp, and network file systems. Arnav will explain the need for KIO, how KIO works, KIO slaves, and how to develop for the same.

At 18:35 Timothée Giet will be taking us down the long road to GCompris-qt 1.0. GCompris, the collection of educational games and activities for children, has finally officially released the new Qt-based version. Timothée will show us the progress the team has made to get there, as well as some shiny new activities.

In the next room, David Edmundson will be explaining the Binding loop detected for property "title"" error, an annoying and cryptic error everyone developing QML has experienced at some point or another. He will talk about what this warning really means and how you can tackle even the most complicated loops.

... And a last Blast of Lightning Talks

At 19:15 we'll have the last three Lightning talks of the day. First up will be Agustín Benito with his Opening new doors presentation, in which Agustín will explain why he thinks KDE should jump into the embedded-for-automotive fray. Should he have called his talk Opening car doors? Definitely.

Then Annu Mittal will talk about all the application domains and various programs currently running in KDE, namely: Season of KDE, Summer of Code, and Outreach Program for Women. She will follow up by explaining the various ways you can get involved with KDE, both from the technical and non-technical point of view.

Finally, yours truly will help you look for love (for your projects) by explaining in ten minutes flat three simple steps that will improve your communication and increase your audience's appreciation for your project.

... And that is just day one.

Register here and don't miss Akademy 2017, one of the most important Free Software conferences this year.

Dot Categories:

Yesterday I got an invitation to the opendev conference (September 7-8, 2017) from the OpenStack foundation. The conference is about edge computing. 

While the topic itself is very interesting I was surprised that the opendev will be held in the U.S. (San Francisco, CA). I thought the foundation would have learned a lesson from the Boston summit this year. And as far as I understood it they decided to have currently no summits in the U.S. anymore until the political climate changed to allow risk free travel for all community members (see Kurt Garloff's talk at DOST around 8:45min). But it seems this applies only to the summits, very inconsistent! Some people would call it slightly duplicitous.

In light of the OpenStack Foundation's decision I'm still proud about the Ceph community. They decided with a clear statement to not held any event in the U.S. that requires travel for community members from foreign countries while there is the risk to potentially suffer harassment, digital privacy violations, or rejection at the border.

This is the third post in my GSoC series. You can read the second one here.

Hey there, a few weeks has passed since my last blog post. I promised to make a new post as soon as I had something cool to show off. Well, after working hard for a lot of time, I can finally show you how the project is taking shape.

First of all let me say that everything I am going to show you is still in heavy development and, as of right now, it does look a bit ugly. But don’t worry, it will start looking better in the next weeks.

The code for the frontend is available here.

Browsing courses

The first thing I am going to present you are the basic browsing functionalities. The user is able to browse departments (the top level categories of the website), courses and read pages.

The home page. Ugly but functional
A course index. The Lorem Ipsum is just there as a placeholder

The pages are fetching the data from a backend server that I am also developing during this GSoC. This server acts a compatibility layer between the current backend and this new frontend. I will write a blog post in the future about this service because it is based on an interesting architectural pattern: backend-for-frontend.

Ui Library

Together with the browsing functionalities I started developing a simple UI library to use with the new WebApp.

Ui Library

The UI Elements are customizable and will be used in the rest of the project.

For example take a look at this confirm dialog

Ui Library

or at this Edit Page button

Ui Library

Building an UI Library is a very long process, that’s why another WikiToLearn developer (Demetrio Carrara) is helping me in the development of this UI Library, he designed and built input boxes and added a few styles to the buttons.

This way I can concetrate in the development of the main functionalities.

Async operations

Another interesting feature I worked on, is the support for polling operations. Right now on the website when downloading a PDF for a course you have to stare at a loading bar for a few seconds (sometimes even a minute or two), this is not ideal. That’s why with this new Web App we are going to execute these long operations in the background, without having the user look at a loading bar.

Take a look at this video. I am clicking a button to start a long operations (which as of right now does nothing) and while the operation is in progress (you can see it in the lower right part of the screen) I am still able to browse the website.

There is still some work to do, for example adding some kind of notification once the operation is complete, or letting the user close the browser without losing the operations, but the basics are already implemented.

Other details

As you can see on the video above there are transitions and loading bars when switching between pages, this is very helpful for the user, the browsing experience is much smoother.

The Web App is also quite lightweight, the external libraries and the code are less than 70KB to download, and once they are cached (this means from the second refresh of the page) they load in no time.

The Web App also supports full HTTP codes when responding to the browser: not many Web Apps do this, but after a few days experimenting and developing various solutions I found the best one and decided to use it.

What’s next?

Right now I am experimenting with user authentication. The available solutions (actually the only solution) for authenticating users that is compatible with Vue does not support Server Side Rendering, which is a must for my web application. This probably means I will have to fork the library and implement support for our use case. This could slow down the development of the web app but at the same time it will be great to contribute to an external project.

I am also working on deploying the Web App on a real and public server, making it available for everyone. It is far from usable by common users but it is a nice way to keep track of progress.

As always thanks for reading and don’t be afraid to leave comments!

We’re releasing the first beta for Krita 3.2.0 today! Compared to Krita 3.1.4, released 26th of May, there are numerous bug fixes and some very cool new features. Please test this release, so we can fix bugs before the final release!

Known bugs

It’s a beta, so there are bugs. One of them is that the size and flow sliders are disabled. We promise faithfully we won’t release until that’s fixed, but in the meantime, no need to report it!


  • Krita 3.2 will use the gmic-qt plugin created and maintained by the authors of G’Mic We’re still working with them to create binary builds that can run on Windows, OSX and most versions of Linux. This plugin replaces completely the older gmic plugin.
  • We added Radian’s brush set to Krita’s default brushes.

These brushes are good for create a strong painterly look:

  • There are now shortcuts for changing layer states like visibility and lock.
  • There have been many fixes to the clone brush
  • There is a new dialog from where you can copy and paste relevant information about your system for bug reports.
  • We’ve integrated the Smart Patch tool that was previously only in the 4.0 pre-alpha builds!

  • The Gaussian Blur filter now can use kernels up to 1000 pixels in diameter

Bug Fixes

Among the bigger bug fixes:

  • Painting with your finger on touch screens is back. You can enable or disable this in the settings dialog.
  • If previously you suffered from the “green brush outline” syndrome, that should be fixed now, too. Though we cannot guarantee the fix works on all OpenGL systems.
  • There have been a number of performance improvements as well
  • The interaction with the file dialog has been improved: it should be better at guessing which folder you want to open, which filename to suggest and which file type to use.

And of course, there were dozens of smaller bug fixes.


The KDE download site has been updated to support https now.


Note for Windows users: if you encounter crashes, please follow these instructions to use the debug symbols so we can figure out where Krita crashes.


(For some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)

A snap image for the Ubuntu App Store will be available from the Ubuntu application store. When it is updated, you can also use the Krita Lime PPA to install Krita 3.2.0-beta.1 on Ubuntu and derivatives.


Source code


For all downloads:


The Linux appimage and the source tarball are signed. You can retrieve the public key over https here:
. The signatures are here.

Support Krita

Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos or the artbook! With your support, we can keep the core team working on Krita full-time.

July 17, 2017

This is a short public service announcement: KWin master as of today requires a compiler which supports C++14. This means at least gcc 5 or clang 3.4. All major distributions support at least one of the two.

July 16, 2017


Sidenote: I'm working on Go language support in KDevelop. KDevelop is a cross-platform IDE with awesome plugins support and possibility to implement support for various build systems and languages. The Go language is an cross-platform open-source compiled statically-typed languages which tends to be simple and readable, and mainly targets console apps and network services.

During last 2 weeks I finished my work on code completion from embedded structs feature I mentioned in previous posts. Also, I improved correctness of methods handling - now they are placed in correct context of DU-Chain. The biggest complexity was the fact that in Go language struct definitions doesn't have any declarations of methods - methods are declared separately, outside the struct context.

Aside from DU-Chain improvements I was working on adding support of launching project within KDevelop. I have researched different ways of handling project building and launching it and I didn't found one which would be "recommended one". So, I took a look on existing IDEs, especially on Gogland and LiteIDE. LiteIDE builds project inside source directory and launches resulting binaries while Gogland builds project into executable placed into /tmp folder. I think that keeping binaries inside sources directory can be not very handy, because they should be added to .gitignore (or similar settings in other VCS). So, I decided to build binaries in separate directory but provide ability to choose that build directory, like in CMake project manager in KDevelop.

For better overview of implemented feature I recorded a small screencast which shows a process of creating and launching Go project: https://www.youtube.com/watch?v=KxIy53i0RK0.

July 15, 2017


Me, Shaza, and Ahmed

It was nice meeting Ahmed and Shaza @ faculty of Engineering, Ain Shams University in Cairo. I am proud to mentor them in Google Summer of Code.

Ahmed is working on implementing a DLNA server in digiKam core to export photo and video hosted in physical and virtual collections. The server is ready and he working on the configuration panel UI. See more here.

Shaza is working on a tool for image editor to be used for healing image stains with the use of another part of the image by coloring by the use of one part over the other, mainly testing on dust spots, but can be used for other particles hiding as well. See more here.

Screenshot with memory use KSysGuard — the system monitor — on FreeBSD seems oddly precise. This machine with FreeBSD 10.3 and KDE Applications 17.04.2 installed, tells me that I have 3,274,960.000000 KiB memory in use. That is, three million, two hundred seventy four thousand, nine hundred and sixty kibibytes. I’m willing to believe that, since notionally the machine has 4GB installed and FreeBSD uses up memory until it’s full and so memory use rarely reports much unused. What I’m less inclined to believe is the .000000 part of the measure: and zero millionths of a kibibyte. So that’s a .. um .. more than a millibyte, and a smidgen less than one one-hundred-twenty-secondth of a bit.

So, dragging in some information theory and plugging in some values,  using the binary entropy function, Wolfram Alpha tells me that

p ≈ 0.999314653604933

so we can be ninety-nine point nine percent sure that that is my actual memory use.

Sometimes it’s good to be precise.

Older blog entries

Planet KDE is made from the blogs of KDE's contributors. The opinions it contains are those of the contributor. This site is powered by Rawdog and Rawdog RSS. Feed readers can read Planet KDE with RSS, FOAF or OPML.