I’m in the process of writing about Calligra, a relatively young project. What I’ve come to realize is that very few developers seem to understand where the world is heading, and even more importantly, where the world is at. The future is on the cloud is something people often hear, and for a reason, because the future is definitively cloud related. The Cloud offers many advantages which are unprecedented, it’s platform agnostic, it can be accessed with any computer from any internet provider from any part of the world… well, perhaps not any, but chances are you’re not trapped between the walls of The Great Firewall.

We know expect devices to be connected all the time to the web, we carry smartphones so we can know instantly when an email has arrived, we suffer from a perpetual state of data hunger, we use applications like Read it Later so we can take pieces from the web when a connection is unfeasible.

What about KDE? Is it keeping at the pace? The problem is many applications seem to be disconnected from the future, or, more plainly said, disconnected from the cloud. I’m picking document editing as an example, but what I will argue applies to most applications.

Editing in the past 

Say you and your colleagues need to write a document regarding how English is world’s de facto lingua franca. If you were to use Calligra, OpenOffice or LibreOffice, you would do the following:

Open up a chat service, or call service, or what have you, to keep in contact with the team. Then all of you would open your local document processor, and start discussing what is the job of each one of you. After a while, you would start sending emails with your share of work attached to every other member, or perhaps, just one, if you previously consented it. Then, someone will put all pieces together, but oh my, it’s clear all of you worked separated from each other, no matter how much chatting there was, so you’re forced to edit many parts to make it fit and seems like a coherent single piece instead of a colage.

Notice this somewhat natural succession of steps has one important characteristic: Users need to use tools completely unrelated to document editing to accomplish tasks related to basic document editing.

Editing in the future

You will only need open your favorite cloud application, add your colleagues, and start editing. All changes will happen in real time, discussion among writers can be held instantly, and without leaving the document editor, by either video or text. There’s no need to send any attachment or to open any specific chat service. In this future, the internet is so widespread that there are no concerns about lack of connectivity, broadband is broad enough to handle all data without hassles, and web standards are evolved enough to offer an experience as fast and as smooth as local application’s.

Another big difference between past’s, present’s and tomorrow’s way of working is that we no longer sync the content of our devices to the cloud, but the other way around, all content on our devices is nothing but a reflection of the content stored in our cloud.

Editing in the present

You have two choices, editing like we did in the past, or editing in crippled form of the future. You may think Google Drive (formerly Google Docs) has reached tomorrow’s levels, that is as powerful as local applications, but that’s simply untrue, nor it is as smooth when working with images or any relatively heavy object.

And this is the key element of this editorial, both of our current approaches are fundamentally wrong regarding the current state of affairs. We either edit like in the past, with application that completely ignore the advantages of the cloud, or with cloud apps that completely disregard the current advantages of local applications, this latter set of programs are developed under the false assumption that the point where cloud apps are as fast and smooth as local apps has come, but this is factually untrue.

How it should be

Any service most be constructed around today’s circumstances, or the circumstances of the near future. Instead of apps designed like Calligra, which adds such a marginal cloud integration to render it practically non-existent, we should be developing local applications that interact with the cloud itself. Instead of Google Drive we should be using something like Calligra but connected (if available) to a real time sync service, so all changes done in the cloud are reflected in real or quasi real time on everyone’s computer. We should be able to add colleagues to the project straight from the app, we should be able to work with local data while everything syncs in the background.

Say you’re working with a 25 MB image, you should be able to work with it without interrupting your current workflow, you work with it locally, while the image quietly syncs with the cloud, once it starts syncing other users should see a place holder where the image is going to be (while it uploads and while it downloads to other’s computers), so it keep editing as close to real time as humanly possible.

At the same time, the chatting service should be integrated into the application itself, you shouldn’t need to use a common chatting service, you should merely need to use the same editing application (and, even this, can be avoided, if we put in place a set of APIs).

Where’s KDE at?

It is mostly in the past, with too slight to matter touches of cloudiness.  There’s little to worry though, as it seems all other operating systems are stuck in the same scenario. But, then again, this is Linux’s and KDE’s opportunity to take the lead, instead of just catching up, current Desktop Environments need to adapt to the current state of affairs as well as its immediate future. As a community, we shouldn’t let our highly powerful and developed Desktop Environment and applications left behind again, as they are regarding touch-input, that said, so was everybody when the iPad and the iPhone arrived, Google has caught up, Microsoft is about to caught up, we’re trying to move faster. This our chance to make the rest play catching up, and we’ve done it before (as I argue for when I introduced package managers), it isn’t a fantasy, is there waiting to be done.