Posted on

Fighting the Schism of Free Software

Over a decade ago an event happened which is still influencing our life in free software. Instead of one, two projects emerged to bring a fully free desktop to Linux based systems. Back then we failed to see the advantages of having multiple available desktop environments and we basically created a schism between the KDE and the GNOME world.

The Schism is still in place!

Without noticing it the emerge of multiple desktop environments (and with that I mean not only GNOME and KDE) created something positive: nowadays we have several superb environments the user can choose from. We have what nobody else can provide: choice of the desktop shell and software for the personal needs. The free software world does not provide a one size fits it all solution, but the user can choose between multiple products. This is a great advantage.

In the end it does not matter whether a user is using GNOME Shell, Unity, KDE Plasma, XFCE or any other environment. As well it does not matter whether he uses KMail, Evolution or Thunderbird. What matters is that the user has been liberated from the lock-in systems of our competitors. Our goals are all the same: we want free software to succeed.

If a user switches from GNOME Shell to KDE Plasma, it is not a lost user to GNOME. It is a user won for free software and not lost to the proprietary competition. If a user switches from KDE Plasma to Unity, it’s not a lost user to KDE, but a user won for free software. We have to realize that we are not in competition with each other, we are in competition with the proprietary lock-in systems. United we have something to compete with our real competitors.

I think most developers have already realized that we are not in competition but have to work together. We can see this through events like Desktop Summit. But if I look around, I see that there is still a war between GNOME and KDE – at least among the users. KDE users are happy that GNOME Shell is not yet ready and similar idiocy. This is something we have to fight. If for example somewhere a user is complaining about KDE Plasma it is totally fine to suggest them to give GNOME Shell a try. We have the choice, we have different environments to support different workflows. We do not provide software which is suited to all users. I am sure we have the software component to make each user happy, we all have to help the users to find the right software for their needs.

When Linus turned first from KDE Plasma to GNOME and later from GNOME Shell to XFCE he was exactly demonstrating the advantages of choice. Neither KDE Plasma nor GNOME Shell can suit the needs of a power Kernel superlord but free software in general does offer the possibility to have a desktop shell available for everyone. These two events have not shown a failure of GNOME or KDE as the media seemed to suggest, but the opposite: it highlighted the great advantage of choice in the free software ecosystem.

My hope is that our users would stop to fight each other. While our users fight, they demotivate the developers, they undermine efforts to improve the collaboration. There is no need to fight for KDE. If a KDE user writes bad about GNOME, he is not harming GNOME, he is harming both KDE and GNOME. KDE and GNOME belong together, we are in no competition, we need each other. Only together we have a chance of bringing the merits of free software to all possible users. I also hope that the media would stop to compare the systems: they don’t need to be compared. GNOME Shell has a different workflow than KDE Plasma. What would be the need for GNOME Shell to simulate the behavior of KDE Plasma or vice versa? Comparing the systems is wrong from the start.

I hope that also the two organizations around KDE and GNOME can help to make a united vision come true. Why is there no mention of GNOME on the KDE web site? Why is there no mention of KDE on the GNOME web site? Why are release notes of GNOME not published on the KDE news site, isn’t it a news worthy event if our collaborators have a release? Why is it so strange that a picture of a GNOME developer is in a release note of KDE that it has to be mentioned in a keynote at Desktop Summit? Such collaborations should be normal and nothing which needs to be mentioned.

And we can also do something to make the acceptance for our users better. New users will end up with either GNOME Shell, Unity or KDE Plasma. There is a good chance that they don’t like the system they got by chance. In that case they are lost again to the proprietary competitor. Why don’t we offer a “discover more” mode in our systems? Make it easy to install and try GNOME Shell from inside Plasma and vice versa. We have so many awesome software and nevertheless we are still in our GTK-only and Qt-only world. Why do we not include GTK applications in the default offerings in KDE Plasma? If there is a better alternative, do we really need to ship a maybe unmaintained and half broken Qt application, just because it’s Qt?

We all – users, developers and media – can do much better than we already do to finally end the schism of free software. It’s not KDE vs. GNOME, it is KDE and GNOME. We are one free ecosystem. If we want we could say KDE Plasma is just another desktop shell for GNOME OS, just like GNOME Shell and Unity are shells for GNOME OS. We have to finally be united to bring the merits of free software to all users. Let’s all pull together to make free software more awesome. Let’s stop the so often childish and ridiculous comparisons between GNOME and KDE software. They are alternative options and not competing products.

Posted on

Developer and User Interaction

A free software project such as the many projects under the KDE umbrella do not need users, they only need more developers. A user which is not able to develop is useless. Because of that it is totally acceptable that you demand that user’s should start learning programming to fix the bugs they report.

Of course such an opinion is as ridiculous as users demanding that bugs get fixed or insulting the developers who spend hours and hours of their spare time to produce an awesome product.

What I want to indicate is that the relationship between users and developers in a free software project is very special. And we need both: we need the developers and we need the users. What’s the fun of developing if nobody is going to use your software? How do you get new software if there are no developers?

A recent incident on a mailinglist and similar incidents before motivated me to finally write this blog post which I had in mind for quite some time. I hope this can help users in the interaction with developers. Now I have to add that I am not an expert in that area and most of the things I put down here are based on my personal opinion and experience.

The Value of Free Software

Free Software is something incredible: hundreds of developers write software in their spare time and not only do they give it away for free, no they also give you the right to do whatever you want with the source code. Furthermore you are allowed to give feedback directly to the developers: through bug reports, through mailing lists, through blog posts and many more possibilities. Each user can interact directly with the developers. There is no expensive support hotline in between. Keep that in mind whenever you have the urge to communicate with developers. It is one of our greatest values and it would be a pity to lose it.

Developers are not evil

No developer is going to destroy his software. No developer is going to introduce bugs on purpose. No developer is ignoring bug fixing. Whatever you think, developers are not evil. They are more interested in a successful product than you as a user. It’s what they invest time for, it’s what they like doing. If a developer is not fixing a bug or not even reacting to it, it’s not because he does not care, it is more likely that he did not see it, that he does not encounter it, that he just does not have time or something else. It’s never about ignoring the user. Also developers do not remove features to harm their users. They have to think about more than just a collection of features. Sometimes it is required to remove a rotten log in order to get something better. It might be worse for you, but in general it’s better for all. Developers don’t change for the sake of change – we are lazy.

You are not a Developer

Remember that you are not a developer. You should not try to discuss about technical details with developers: you cannot win. No matter how good your opinion is, no matter how smart you are, the developer is most likely an expert in his area and has a better view on issues. If he tells you something is not possible, it most likely is. If he tells you he cannot fix a bug, that’s the case. If he has to remove a feature, he has to. Please accept it, don’t argue, you will make a fool out of yourself.

Developers might be busy

Even developers might be busy: they have a day job, they might have to learn, they might have to write a thesis. Accept that they cannot answer to your bug reports instantly. It may take some days, maybe even months till there is a response. It’s not optimal, but that’s the way it is. Please also respect the private life of the developers: don’t query them in IRC without asking, don’t send them private mails asking for bug fixes. At least for me it’s a certain way to ensure that the bug won’t be fixed any time soon. Just think if everybody would send their bug reports via private mail, it doesn’t scale.

Bugs belong into the Bugtracker

It’s obvious, right? A bugtracker is the only available tool to ensure that the bugs can be tracked. A comment on a dot article won’t fix your bug, a mail to a mailinglist will be ignored. Use the bugtracker. Even if it seems to be a dumping place, it’s the best we have.

Don’t state the obvious

A unresolved bug in the bugtracker is not fixed. You don’t have to repeat in each minor release that it is still not fixed. If it were fixed, it would be closed or you could close it. Repeating the obvious just causes even more mail in my already overcrowded mail account and it does not increase the chances that I fix the bug for the next release.

Not all bugs are equal

Just because you have a bug which really annoys you, don’t assume that anyone else has the bug. It’s possible and likely that no developer is using the same workflow as you do. So the very obvious bug might be completely hidden to the developers. Also developers run a different version than you do: they run the latest development version. They might be not aware of a bug in an old version. So don’t assume that everyone sees your bugs.

Everybody has his pet bugs

Yes, you are not the only one having bugs. At the time of this writing the KDE bugtracker lists 23374 open bug reports with a rate of more than 400 new bugs per week (more gets closed). So every user has his personal very important bug which has to be fixed. Also there are many more open bugs than the developers could fix. Yes it’s software, yes that is normal. So don’t rally for the bug to get fixed. I as a developer decide which bug I’m going to fix and if I see that you think your pet bug is more important than the pet bug of someone else, I go for someone else pet bug.

Don’t insult

It should be obvious but it isn’t. Don’t insult the developers. It won’t help your case. Do you really think I’m going to fix your problem (which I do not experience) if you are insulting me? It is contra-productive and harmful. Remember that we spend our spare time. If I get insulted in my hobby, I might pick a different hobby. Your problem is never that important that it is worth the risk that developers are leaving the community.

We are not going down the GNOME road

It’s the argument I hate most when it comes to adding new features or removing existing ones when needed. Nobody is going down the GNOME road and it’s a very insulting statement towards the awesome GNOME developers for whom I have great respect. Such arguments are not going to help you: you want a feature and you try to convince me with such an argument? If you need a feature convince with real arguments under consideration that the developer has to take care of more than just collecting features.

Features are Expensive

Each added Feature means more code to maintain, more code paths which could break, more time to spend, less users which actually use a given code path and by that worse testing. There are valid features, there are not valid features. If the developer decides against your idea, please accept it, he has to take care of more than adding a bunch of functionality. Also please think about how likely it is that you find a new great idea which has not yet considered in the past? Please also use brainstorm.forum.kde.org to suggest new features. Everything else is most likely to just be ignored.

Developer Mailinglists are for Developers

It’s great that users can follow the development process directly by reading the internal mailinglists. But please remember that this is the think tank where the developers need to speak freely. There they exchange their ideas, there they might post controversial ideas on purpose. Don’t jump in and tell your opinion on how stupid the developer is. The mail was not intended for users but to get valuable feedback from other developers. Respect that, don’t destroy the discussion by pulling it in the wrong direction.

Don’t mention the war

Yes KDE 4.0 was a bad release, not ready for productive usage and aimed at developers. There is no reason to bring up KDE 4.0 in a discussion about a present bug or missing feature. It is our past and we cannot change it, especially not the developers who joined after 4.0. If you keep mentioning the state of 4.0 people will ignore you, even think that you are a troll. So just forget about it.

You don’t need to learn C++ to help

Everybody can help, so please give something back. It’s the best way to convince developers to fix your bugs by becoming part of the community. There’s documentation which needs to be written, there are translations which need to be done, there is a marketing team which needs help, there is user support which is lacking supporters, there are designers who need more clones, there is the bug tracker which really needs to be cleaned up. Especially if you hate that your bugs don’t get fixed, help the developer team by taking away the burden of going through all the useless and duplicate bug reports.

I hope these items help to keep KDE the friendly place which it is and helps to keep the relationship between users and developers healthy.

Posted on

Second Strike for KWin Scripting

I already blogged about it: KWin Scripting needs help from the community if it should be available in 4.8. Unfortunately nothing changed about the state, except that I added a build flag to not compile Scripting.

I just wanted to apply a patch and got a compile error because of scripting and I remember that my GSoC student had also problems with scripting during his project.

So this is the second strike for scripting. And you know what will happen when I have to proceed to the third strike 🙁 Step up now, or scripting will have to go.

Posted on

Rendering at 60 Frames

Full credits go to Alex Fiestas for complaining about the performance in a way that I wanted to do something about it, instead of being just annoyed and ignoring the comment!

Alex’s complaints got me wondering why we are not able to render 60 frames/second. Each frame should only take 16.67 msec and knowing that our repaint loop is fine, I could not imagine how a frame could take longer to render than the 16.67 msec. Knowing the KWin’s source code pretty well I suspected two parts of the repaint loop to be slow: the method which actually renders each window and our effect chain. The effect chain calls each effect in turn to transform windows. I had an idea to improve the effect chain for quite some time by calling only the currently active effects. That is currently each effect checks first whether it is active and just does nothing. So you basically call all effects again and again and nothing is actually performed except waisting cycles on checking whether it should do nothing (some effects are heavy there).
Of course I do not just optimize without checking if the code needs to be optimized, so I did an analysis of callgrind output and I was surprised. The effect chain was way more heavy than expected. In fact it’s so heavy that the paint method doesn’t matter in comparison. A deeper analysis of the code showed that there is a small bug, which we will fix in 4.7.2 (too late for 4.7.1), so that we can give the benefits as fast as possible to our users. But the real optimization by only calling the active effects will hit only 4.8. After that change the effect chain is no longer visible in the hot pathes of KWin. Also the change immediatelly helped to identify some expensive checks in some effects which are now ensured that they are not called in each frame (unless the effect is active).
After the optimization of the effect chain we are still not yet there and do not reach 60 frames during the animation, but you can really feel the improvements 🙂 Now the paint method shows up as one of the most expensive in callgrind (as expected previously) and I will now spend some time and thinking in how to optimize this one further by moving heavy operations out of the repaint loop.
In the long term I hope to be able to move the compositor into an own thread (also something I have in my mind for quite some time), so that heavy operations in window management and the decoration plugin do not slow down the repainting of the compositing. This might be tricky as we can run into dangerous deadlocks (imagine compositor and window manager both blocking the X Server), so we will probably first concentrate on moving e.g. texture loading into threads – something one of our new deelopers in KWin experimented with.
Overall very nice improvements, I’m happy with, but not yet satisfied as we do not yet reach the constant 60 frames/second.

=-=-=-=-=
Powered by Blogilo

Posted on

Thoughts about KDE Plasma on non-Linux Systems

This post represents my personal opinion. It does not need to represent any official opinion from any association I am involved with.

The Readme of the KDE Plasma Workspaces states clearly that our desktop is an X11 desktop environment:

KDE Workspace consisting of what is the desktop. The applications and libraries included aren’t required to b e portable and probably will only work with X11. On other desktops such as OS X and Windows, users wouldn’t r un these applications, but use the native ones instead. The typical application shouldn’t have dependencies i n workspace unless they are a component such as a screen-saver or panel applet.

So what does that mean? Our base system should work on every operating system supporting X11. Be at Linux, FreeBSD or Solaris. But how does the world look like, is this still the truth?

The world around us is changing and I would say that the statement is no longer true and soon needs to be adjusted to also include Wayland. This shows that we are at the point thinking beyond the X Windowing System. So what does that mean for the operating systems we support? At the moment Wayland is a Linux only system and given the current requirements it looks unlikely to be supported by non-Linux systems any time soon.

Wayland is of course only one example. There are more. Think about the deprecation of HAL or introduction of systemd. HAL we are still able to support in KDE thanks to our good hardware abstraction through solid. Systemd is not yet used, but I hope that this will change soon. Given these changes we must face the from a technology point of view all non-Linux are far behind Linux which means that on the long supporting the legacy technologies only for non-Linux becomes more and more a hurdle.

Personally I do not know any core developer of the KDE Plasma Workspaces using a non-Linux operating system. So you would expect that we have lots of bug reports for the non-Linux OS. Given that we already have hundreds of bug reports in KWin just about the stack on Linux which we use, there have to be even more for the non-Linux systems. No dev uses it, it gets not as tested as our Linux system, so there have to be bugs! So here the stats for KWin over the last 12 month:

  • Linux: 1054 opened bugs
  • FreeBSD: 4 opened bugs
  • Solaris: 3 open bugs

All three Solaris bugs are actually build errors on Solaris containing patches – they should have been opened on reviewboard. Due to miss of quality non of the patches was included in the software. From the four FreeBSD bugs, two are crashes lacking debug symbols – something that does not happen on Linux any more. One bug was actually also present on Linux, but seemed to only apply for legacy technology. So we have something like 250 bug reports for Linux for each non-Linux bug report.

For Plasma it’s 3529 bug reports for Linux compared to 30 non-Linux (only X11). From the seven Solaris bugs, six are again build failures. FreeBSD are mostly crashes again with missing backtraces and so on.

So this tells us that basically Solaris does not have any users and that it only creates work for us, because they use different compilers. Nevertheless we do not seem to accept the patches. So it’s great that Solaris wants to provide packages for our workspaces, but it should not create work. And yes reporting a bug and discussing it and even rejecting a patch is creating work.

And there is more we have to consider: KDE Plasma Workspaces are nowadays more than a set of applications for X11. It’s an integrated system providing a consistent user experience. Important parts of this experience is also our Oxygen design which does not only require compositing but also advanced OpenGL effects such as the Blur filter. Unfortunately free drivers are not able to provide these requirements on non-Linux systems due to lack of KMS and Mesa frozen at the last version before KMS. What we provide for non-Linux does not match what we want to provide.

The free desktops still have a considerably small market share, but as also the bug reports show the non-Linux users make less than one percent of our user base. If we now think about the global market share for non-Linux KDE Plasma systems we come to a number very close to 0. Our resources are spare and we should make the best out of it. Spending time on hardly used systems which are lacking behind in the technology we want to use and cannot provide the minimum requirements for our workspaces, does not sound like a sane idea to me.

To me it is clear for quite some time already that I won’t accept patches any more for non-Linux. Including another code path or even a build flag for non-Linux systems is not worth the increasing maintaining costs. If non-Linux systems want to include patches they should do it downstream.

Also for the inclusion of new technologies we should not wait for the non-Linux to catch up or do sacrifices in order to still support non-Linux. If a new technology brings us great advantages on Linux but means we have to stop supporting non-Linux because they do not provide the technology, I think it’s better to be really good on the one system.

Please remember: this is my personal opinion.

Posted on

Smooth Window Resizing

As Thomas does not blog and this is quite impressive, I had just to do a video and provide it here. Without further ado I present smooth window resizing with KDE Plasma 4.8:

(Direct Link)

Much Kudos to Thomas for fixing the XSync implementation inside KWin!

Posted on

Guest Post: Crash – Exam – Relaunch

This is a guest post from my Google Summer of Code Student Arthur Arlt.

Isn’t it a funny title for a blog post? But there is a reason for that because it happend a lot in the last weeks…

Crash

Having done my first review requests for my GSoC project, my new (six week old!!!) solid state drive stopped working from one moment to the other. I tried to get it running in other systems, but it was no longer detected by any BIOS. Taking a look at the homepage of Kingston I had to discover, that they found a technical issue of exactly that brand of SSD I had installed to my system. They are strongly recommending to do a firmware upgrade because this failure could lead to a total crash of the drive…
Thanks for the information 🙁 Luckily I made my review requests before, so at least the work done for GSoC so far was saved. But everything I did in these six weeks on my laptop is gone…
I got the SSD replaced, but this took almost two month, since the producer had to check by itself that the SSD is broken… So I bought a new one, because it was no fun working with my slow, old HDD.

Exam

I did not have too much time to be angry about the loss of data. I had to study for an exam in “Principles of Dependable Distributed Systems” which took place at Friday before Whitsun. After that, I have spent a lot of time to (re-)set up the build environment during the holidays.

Relaunch

I am now working into Martins hands supporting him to port KWin to Wayland. Especially the class Scene and its subclasses were provided with some signal and slot functionality.
A very important step to Wayland is to remove all X11 specific stuff from class Toplevel and to insert it into a new class XWindow which will then provide the functionality for X11 based windows. This refactoring emerged to be too difficult at that moment and Martin and me decided to do some other refactoring first. The parts I am currently working on is on the one hand to move all Workspace functions implemented in the file composite.cpp to an own class Compositor. On the other hand I am introducing a new class
DecorationPaintRedirector, which handles the composited decorations.

Work done so far

Some functionality of KWin was moved to own classes or even deleted. For example the broken functionality of TopMenu was removed. The functionalities of screen edge handling and Tabbox were moved to its own classes. The same happend to the tiling functionality. I also added some build option to chose whether KWin should be build with or without supporting a specific functionality. These build options are provided for Tabbox, Tiling, DesktopChangeOSD and ScreenEdges. They are automatically deactivated if building KWin for mobile devices is enabled.

Benefits

Thanks to the refactoring work done so far some parts of KWin are better structured and readable as before. One thing which confused me when I was starting coding for KWin was that in one file there could be several classed implemented. That issue was changed for some classes like Tabbox and Tiling by introducing new files or classes and by moving the related functions to the appropriate classes. These changes do not only make the code better readable but also better maintainable.

Desktop Summit

Two weeks ago I attended the Desktop Summit 2011 in Berlin. I was helping as a volunteer for video operation. Since I did not know anyone there, doing the volunteer work was a great decision. I never expected that I will get to know so many nice people. I was talking to other GSoC students and we were telling each other about our projects and the current state. Meeting some developers of KWin and Plasma was a great occasion. It’s kind of funny meeting them in real life if you had only virtual contact before 🙂 Last but not least the daily social events were the best opportunity to meet new friends. And one can say: Partying with open source people kicks ass!
The days in Berlin were very exhausting, but I had a wonderful time and I don’t want to have missed it.

Outlook

The GSoC project “Modularization of KWin” did not have a specific goal to reach, since we did not know how much work it will be to refactor all this stuff. One can say that there are still lots of things to do, but I am satisfied with my work done so far. The main point for me was to get into the community and I can say that doing a Google Summer of Code is a great opportunity to achieve this. I am really looking forward to go on with my contribution on KWin because it is really fun working with such a great team.

Cheers,
Arthur

Posted on

KWin turns 12

Today twelve years ago at 23:26 Matthias Ettrich did the first ever commit to KWin:

Say hello to kwin. WARNING: NOT USABLE YET. See README.

Given this nice warning we also have to show the content of the README:

This is the beginning of kwin, kwm next generation.
WARNING: this thing is hardly usable now, neither ICCCM nor KDE
compliant yet!
All it has is a context menu that allows you to switch between two
decoration styles, KDE classic and an experimental style.
Please don’t work on the code, I’ll finish it during my summer
vacations (four weeks from now on).
kwin was only commited to allow people like Mosfet to have a look at
the Client API (and StdClient) to write nifty new themable decorations.
Have fun,

   Matthias

As we can see KWin has its root in KWM from KDE 1 (there are still one or two comments in KWin source tree saying KWM) and it seems like the capitalizations was added in later times 🙂 
Matthias seems to have been a little bit too enthusiastic about how much time it needs to write a window manager. It took 8251 commits (1195 translation commits) by 284 contributors (including scripty and cvs/svn migration tools) to get to where we are today. And still we are not finished with KWin. After adding Compositing Support to the Window Manager we are now adressing the second big transition to support more than just X11. So exciting times are ahead of us.
Let’s work together to make KWin rock the next 12 years even more than the last 12. Billions of devices are out there which want to be using KWin as their Wayland Compositor. Let’s work on the future for the free software eco system!

=-=-=-=-=
Powered by Blogilo

Posted on

Thoughts about Network Trancparency

Every time there is an article about Wayland you can see that there a lots of uneducated comments about the “fact” that Wayland does not support network trancparency and because of that it is completely wrong to go for network trancparency. These discussions contain a lot of myths and even FUD and I consider it important to share my thoughts about these concerns as I am belonging to those who actively work to bring the benefits of Wayland to the KDE Plasma Workspaces.

Wayland Could Use Network Transparency

Nothing in the Wayland protocol forbidds network transparency. It is not yet implemented, but it is possible to implement it. Wayland uses a Unix Socket for communication but I think it would be rather trivial to either add network transport to the Wayland protocol or to just forward the buffer in the compositor. Stating that Wayland does not support Network Transparency in general is just wrong. It’s not yet implemented but many things are not yet implemented. Obviously it’s true that the Wayland protocol does not support the X11 Network Transparency as it’s not X11 (and that is a good thing). Obviously even a direct X11 successor (let’s name it X12) would also not support the X11 Network Transparency.

X11 Network Transparency is not Suited for Modern Applications

The idea behind the network transparency is to send drawing commands over the wire (useful idee for the requirements of 30 years ago). Nowadays modern applications do not use X11 any more for rendering. They use technologies like Cairo, Clutter, QPainter (Raster) or OpenGL directly. Without using X11 for rendering you end in streaming pixels over the wire. And there are clearly better technologies to do that than X11. Face it: network transparency is going to break very soon even without Wayland. I want to see the Qt 5 used over the wire.

Modern Applications require DBus

Yes DBus is not network transparent and yes most modern application use it, for things like StatusNotifier (this one has fallback to Xembed) or moving the menus somewhere else. Now without network transparency these things are just shown on the wrong system or not at all. Damn stupid devs not thinking about network transparency… So face it: no modern app can be used without DBus which breaks implicitly also the X11 Network Transparency.

Wayland targets Mobile Devices

Those who attended my presentation at Desktop Summit or who have seen my slides might have already got the message: we don’t want to break the desktop and will therefore only target mobile devices in the beginning. The same is true for MeeGo (they don’t have a desktop) and hopefully also GNOME Shell and Unity. So do you really want to forward your X11 application from your (mouse+keyboard) desktop to your touch tablet/smartphone? Probably not. So why do you care about network transparency not available on mobile? For mobile the target groups are the billions of users out there who do not even know that network transparency existed and not the five geeks who cannot live without it. Face it: you are not in the target group of Wayland on mobile devices if you need network transparency. (You probably wouldn’t use an iPad either).

Desktop will continue to Support X11

We will only switch to Wayland as our primary windowing system if we can continue to support legacy X11 applications, because we don’t want to break the desktop. This means you can still run your legacy X11 windows over network even under Wayland and also X11 applications on the Wayland system can still be forwarded to a remote system. So I hear you already complaining about the Wayland windows not being able to be forwarded. Well if the toolkit (like Qt) supports multiple backends there is no reason why you should not use the X11 backend to forward the window. Apart from that: remember, it would not be working at the time when we switch to Wayland even under X11 (see above).

Network Transparency Does Not Belong Into The Windowing System

Adding Network Transparency in the Windowing System is the wrong layer. The windowing system only receives the pixels and that can never be performant. Network Transparency needs to be added to the layer which does the rendering. That used to work with X11 as X11 also did the rendering, but this is not true any more. We need support for Network Transparency in the toolkit. Just imagine the possibilites: remote applications picking up your local font settings, color themes, icon themes… That’s what needs to be done!

But Distros will remove X11 support in $X Years

As long as there is a demand for legacy support distros will still support it. Especially I don’t think that enterprise distributions will dare to remove it in the next 10 to 20 years. Remember that also Mac OS X still supports legacy X11. And even if the distro removes the support: who stopps you to package X11 yourself and provide it to everyone who needs X11? Btw we are talking here about at least three to five years – others have predicted the death of desktop till then.
I hope this post can help to bring future discussions about Wayland to not keep repeating what has already said and is just wrong.

=-=-=-=-=
Powered by Blogilo

Posted on

KWin at Desktop Summit

Wow, what a week! It’s just great to be at Desktop Summit again and meeting all those KDE people again and also the GNOME people which gives the event a different and pleasant touch.

The big topic for me at this Desktop Summit is to lay out the foundations for bringing the KDE Plasma Workspaces from the X11 Windowing System to the upcoming Wayland windowing system. This is an effort which will most likely take years, nevertheless I am hoping that we find enough interested developers to have something ready as a developer preview in our next release. The complete plan has been outlined in my presentation here at Desktop Summit. It seems like my slides and video recordings are not yet uploaded, but I put my slides in our wiki. If you can read German you can also have a look at my article in the current issue of freiesMagazin, where I wrote down what I talked about.
As there was some media coverage about my talk and also about other changes in KDE which are completely unrelated I just want to point out that the work going on for KDE Frameworks 5 does not influence our development of the desktop at all. This means we will continue to release further 4.x releases of the KDE Plasma Workspaces. Also given the changes which are going to happen in KDE Frameworks it will not be disruptive to the desktop. This means that there is no reason to use a “5.0” release to switch the windowing system from X11 to Wayland. We will switch when we are confident that we do not break the users’ desktops.
I also read some concerns about that we would remove the X11 Network Transparency. Relax: we don’t want to break our users’ desktops. Just have a look at this architecture:
As you can see even with Wayland as the windowing system we will continue to support remote X Clients.
Yesterday we had a BoF about the changes needed for Plasma. We did unfortunately not agree on that much, but I will put up a wiki page with small TODOs, so that others can work on it. The BoF turned out into a discussion about Client Side Windowdecorations, which I did not want to spend time on. But in the end I think it was useful as now developers from other projects understand our position better and can understand why we will stick to server side decorations even with Wayland. I will soon write down a policy to exactly specify when windows will be decorated and when not and implement it for 4.8 (should only require minor changes).
On a completely unrelated note: thanks to the decision of three persons, I will be going to Akademy 2012. Thanks very much for the award.

=-=-=-=-=
Powered by Blogilo