Healthy relationships. I've been thinking about them not in my personal life, but in terms of teams in free software. When I first began contributing, it was within a team creating an application (Amarok), so rather small. Then I became active in Ubuntu-Women, which is larger, but still not huge. Then Kubuntu, then the larger Ubuntu community, and now KDE, which is truly enormous.

In all of these projects, communication and trust are paramount. Dialog which fosters creativity and progress is only possible when people enlarge their trust in one another. Along the way to the highest trust levels, many barriers will come down, as people allow them. Sometimes these barriers are invisible, until someone points them out.

I thought I'd seen a cartoon illustrating this story, but a web search tells me it's a story by David Foster Wallace:
Two young fish meet an older fish, who asks them “How’s the water?” The younger fish look at each other and say, “What the hell is water?”I was reminded of this story recently while observing the various reactions to the removal of the Community link on Ubuntu.com, the portal to the Ubuntu project. The link is coming back, so I'm not complaining. However, what I've noticed is that most of the people discussing the issue seem to be talking past the folks they are hoping to connect with. The emotions expressed range from puzzlement, to shock and outrage, with little understanding on the other "side" on the perceptions causing these reactions.

So how is the water? To me, the drama played out completely predictably, because any time you have one company selling a product, and volunteers working in that same project, you will have class issues, and class is like the water fish swim in. People are often not aware of it, and thus have difficulty dealing with their emotions around it, because they have been taught to ignore it, or even that it doesn't exist. So when the designers removed the link, it was felt as a slap to the face of community members, while the designers see it as just a step to a clean, functional design. The conversation about this change at the recent vUDS clearly betrays this lack of understanding of the other on all sides. http://summit.ubuntu.com/uds-1305/meeting/21740/community-1305-ubuntu-website-planning/

There is no such thing as a culture without class. There are always power imbalances, and privileges. However, that doesn't mean that class is the death of the Ubuntu project, or that volunteers and companies can't happily co-exist. They can, but the fact of class must be acknowledged, and those with privilege and power must realize what they have, and use them on behalf of the project.

A healthy culture has hierarchy, but not one based on domination. In fact, in FOSS that is part of what we are attempting to dislodge, right? We want our hierarchies to be constructed for function, not to rule over us. For instance, those who demonstrate their skill in packaging or coding are given the right to upload to the repositories. And those who grant them that right are those who already have built their reputations by using their skill and trustworthiness in that domain.

Recently there has been a breakdown -- or an apparent breakdown -- in that hierarchy of function in Ubuntu. And I think that both those inside Canonical and those outside, perceive that the other is the one causing that break. So, some repair is needed.

All of our differences can be overcome as we build (or re-build) trust. However, all sides of the issue will need to think about, process emotion about, and finally discuss openly what has gone on. The replacement of the Community link alone will not mend this breach, nor will brief virtual UDS sessions. In fact, I think the lack of in-person face-to-face interaction is allowing this divide to grow.

Folks, we don't want resentment and suspicion to grow, so we are all going to need to work on this if the Ubuntu project is going to continue to thrive as a free software enterprise. In my opinion, thinking about and discussing class issues are fundamental to that effort.

This blog appears on the Linuxchix, KDE and Ubuntu planets, and these issues of class appear in all teams. Health and progress are the goal, and honest dialog is the means. I propose we look one another in the eye and start a conversation. These are difficult dialogs, but our health is at stake.

Globaleaks 0.2 Alpha is out.

Globaleaks is an open source project aimed at creating a worldwide, anonymous, censorship-resistant, distributed whistle-blowing platform. It enables organizations interested in running whistle-blowing initiatives to setup their own safe zone, where whistle-blowers and recipients can exchange data.

2 Years ago I helped out with the development of Globaleaks 0.1. And although I am not active anymore, I really support the initiative behind it. Now with the HERMES Center for Transparency and Digital Human Rights backing it up, it has grown a lot and shaped up to be a very organized and thought through project.

TL;DR:

• Full rewrite
• More flexible and extensible
• Linux ready-made system and network hardened installation
• Written in python using twisted
• New Frontend

Try it out:

Try out the demo. It is pretty straight forward.

Help out:

As young project, Globaleaks can use some help fixing bugs. Just head to the wiki and read through it. It is pretty straight forward, and explains the modules, security concepts and set up instructions.

Globaleaks already has Debian and Ubuntu ready packages. An easy way to help out is to set up a  PPA for us on Launchpad.

Get in touch:

You can contact the Globaleaks team at info () globaleaks org or on IRC on #globaleaks at irc.oftc.net

Here are some screenshots of the new frontend

Congratulations you are using Tor

Receiver selection page

The submission receipt

Configuring a receiver

Configuring a context

It’s one of those yearly things, scheduled for less than two months from now. Frankly, I’m a little surprised that no one else — Paul Adams is a usual suspect — has bunged up some badges for this year yet. So here’s my entry for Akademy 2013 in Bilbao, showcasing, as always, my most excellent kolourpaint skills. And, like it says on the tin (brass? what material are badges made of anyway), Akademy doesn’t fit my schedule this year either. My only remaining hope is to integrate the conference with a three week train-and-bicycle vacation for two adults and two kids.

A great piece of news for Ubuntu Krita users is coming today! We have just opened a repository with regular builds of Krita git master!

Link: https://launchpad.net/~dimula73/+archive/krita

The main purpose of this PPA is to provide everyone with an always fresh version of Krita, without the need to update the whole system. Now one can get all the latest Krita features without a delay.

At the moment git master version has at least three features, which are absent in Krita 2.7 Beta1 (and cannot be merged there due to code freeze):

• New "New Image From Clipboard" dialog with a nice preview widget implemented by our new contributor Matjaž Rous
• New "pseudo-infinite" canvas feature (read here) for dynamical image resizing
• New "Overview Docker" which lets you see the whole image at a glance

To install the newest Krita you need to do a few steps:

1. Check that you don't have any original calligra or krita packages provided by your distribution or project-neon (we don't check that automatically currently)
2. Add the PPA to repositories list:
   sudo add-apt-repository ppa:dimula73/krita
3. Update the cache: sudo apt-get update
4. Install Krita: sudo sudo apt-get install krita-testing krita-testing-dbg 

Update:
After installing this package you should restart X-server to get environment variables updated!


Of course, being based on git-master may sometimes result in a bit of instability, so make sure you report any problems so we can fix them! :)

What does every development team want? New contributors!

I'd like to suggest a simple process that can turn visitors to your website, list or IRC channel into a successful part of the development team. When people actually contribute, they quickly feel like a valuable part of the group. New people bring fresh energy, and new ideas.

At your next sprint or meeting, start dreaming. Is your user documentation well-written and up-to-date? Do you need promotion, or video guides? How about art or diagrams for your website? Speaking of your website, when was the last time all the links were tested, and it was checked for spelling and grammar? Create a nice, friendly list of tasks for your newcomers.

Could your codebase use some grooming, for common misspellings, for instance? (EBN is a great source for these). When you run across a bit of code which needs pruning or refactoring, or normalizing signal-slot stuff, the easy thing is to fix it while it's in front of your eyes. Instead, consider which of these small tasks can be filed as a "Junior Job", created for the purpose of getting those knowledgeable people to move from faithful user, to part of the team.

The Bugsquad and Quality Control teams can likely suggest more ideas, too.

KDE Junior Jobs can be easily found: http://kde.org/jj. Teams can create their own shortcut links too, such as Amarok has done, listed in the #amarok IRC channel topic: http://tinyurl.com/amarokjjs. Other tasks can be blogged about, posted on a trello, on the Community wiki; whatever your team likes to use. For more ideas, see http://community.kde.org/Getinvolved.

The Kubuntu team has a list of tasks in Trello, which works well.

So, when you feel like not fixing a little issue, don't feel lazy. Feel responsible! File a bug, make it a JJ, and call attention to those issues when new folks show up and ask, how can I help?


PS: Thanks to the #kde-www team for suggesting this blog. Einar77, neverdingo, mamarok; you are wonderful.

PPS: How LibreOffice does it: https://wiki.documentfoundation.org/Development/Easy_Hacks

In KMail all themes are hard-coded, so it’s not possible for end user to customize his mail header theme.
It’s right in KMail we have several themes:
- fancy Headers

• enterprise Headers
• Brief Headers
• Standard Headers
• Long Headers
• All Headers
• Custom Header (in 4.11 see previous blog)

But to improve it we need to help user to create them.

So I studied Grantlee.
Grantlee is an HTML generator. So it was ok for header theme.

Grantlee generates HTML from an initial HTML template + some keywords defined by developer.
So now just an HTML developer can customize it, it’s not necessary to rebuild KMail.

And I used knewstuff library to allow to upload/download new themes as you can see in next screenshot:

Ok I am not a artist, I can’t show you a new theme, but you can see that I can recreate fancy theme with Grantlee.

Example:

<div dir=”ltr”>
<div dir=”ltr”> {{ header.subject|safe }}
</div>
<table>
<tbody>
<tr>
<td width=”100%”>

<table>

<tr>
<th align=”left” style=”font-size: 10px;”>{{ header.fromi18n }}</th>
<td style=”font-size: 10px;”>{{ header.from|safe }}

{% if header.resentfrom %}
&nbsp; {{ header.resentfromi18n }}: {{ header.resentfrom|safe }}
{% endif %}

{% if vCardName %}
&nbsp;&nbsp;<a href=”{{ header.vcardname|safe }}”>{{ header.vcardi18n }}</a>
{% endif %}

…….. (see all theme code in messageviewer/theme/example_fancy/header.html)

We have a desktop file which define theme name but also the extra headers to displaying.

In example I add “Sender” which is not default header.

I hope that it will have more header theme create (I created a application for generate them, I will blog about it soon)

This week I decided to do some research for the Wayland porting of the KDE Plasma workspaces. One of the features we will need in future is a Wayland session compositor which runs nested on a Wayland system compositor. Of course one could think of setups without a system compositor, but overall I think that a nested compositor simplifies the setup and allows to have all the low level technologies in one place without duplication in all the various compositors. +1 for working together.

After three days of work I already have something to demo (video on youtube):

Sorry for the bad audio. I’ll just explain what one can see. The video starts with the normal X-Server. After that it switches to a VT and we start Weston there. On Weston I’m starting KWin with some environment variables set to pick the correct libraries and force KWin into Wayland mode. KWin creates a connection to Wayland, creates a Wayland surface and uses it for OpenGL output. All the windows from the running X Server are rendered into this surface just as if it were a normal X11 output.

KWin also gets input from Wayland and passes it to the X Server. That’s the reason why we can see mouse interaction and working keyboard.

How it works The OpenGL backend

KWin supports multiple backends for providing an OpenGL context and doing the texture from pixmap operation. At the moment we have an GLX and an EGL backend. Both create the OpenGL context on the XComposite overlay window and provide the texture from pixmap in the GLX case through the GLX_EXT_TEXTURE_FROM_PIXMAP extension and in the EGL case through the the EGL_KHR_image_pixmap extension.

A new backend is added which creates the OpenGL context on a Wayland surface. The backend started as a fork of the existing EGL backend with the X code stripped out. What’s a little bit tricky is getting the texture from pixmap working. The extension used in the normal EGL on X11 backend is not available. The proper solution would be a setup with XWayland, but that’s still too early as KWin does not yet support Wayland clients.

The solution I came up with is inspired by a fallback mechanism in KWin from the time when GLX_EXT_TEXTURE_FROM_PIXMAP was not guaranteed to be around: XShm to copy the pixmap content into an OpenGL texture. Not a nice solution but it works.

Input handling

Input is currently also a rather hackish solution until we have XWayland up and running. We just take all input events and forward them to the XServer with the XTest extension to inject fake events. It’s a huge hack and one can see how old X is there and how limited. I was rather surprised that it works at all. At the time of this writing the code supports keyboard events and the left, middle and right mouse button. Wheel events are tricky as X uses mouse buttons for them and for more mouse buttons I have problems with mapping them as I’m lacking a multi button mouse.

We are also not able to back sync the mouse position from X to Wayland. As far as I understood the Wayland protocol there is nothing like XWarpPointer, so if something in X warps the pointer we have a mismatch. I agree that warping is evil, but we use it in KWin for activating the screen edges

Next Steps Cursor

What is to do next is to get the changes to the cursor in X11 and set the cursor on the Wayland surface. That should not be really difficult as the XFixes extension provides everything one would need for that.

Thread

A rather huge limitation at the moment is that the connection to the Wayland display is hold in the main thread. We cannot block there, so we only get events when we actively check for them. This is currently during repainting the screen. So if you wondered why the ShowFPS effect in the video is turned on: it’s to force repaints and to keep the connection alive. This connection needs to go into a thread so that we can block there.

Buffer age

Currently the code forces as to do full-screen repaints. The two solutions we have for non-fullscreen repaints in the EGL backend do not work in the EGL on Wayland backend. The Wayland demo code shows that the EGL_EXT_buffer_age implementation could be used. We wanted to have support for that one anyway in KWin.

Giving it a try Building from source

I just pushed the code into branch “kwin/wayland-egl-backend” on my clone kde:clones/kde-workspace/graesslin/kde-workspace. Be aware that I intend to force push to this branch.

To build you need to have the Wayland libraries around. The CMake module tries to find it through package kit. Watch the output of CMake, Wayland is only an optional dependency! If you build Wayland and Weston from source, please follow the instructions. You might also need to build Mesa from source.

How to start

Starting is rather simple. Just have an Xserver running somewhere, start Weston on a VT (don’t do nested on X, you would only get a black screen once KWin started) and open a terminal. Setup your environment variables to be able to start KWin and then start KWin in the following way:

DISPLAY=:0 KWIN_DIRECT_GL=1 KWIN_OPENGL_INTERFACE=egl_wayland kwin --replace &

KWIN_DIRECT_GL makes KWin skip the OpenGL Test application which is currently only supporting GLX and seems to fail if one is on a different VT. KWIN_OPENGL_INTERFACE tells KWin which backend to use. So by using “egl_wayland” one forces KWin to use the Wayland backend. In future we will probably detect whether the Wayland display environment variable is defined and just pick it directly (though that is dangerous in case of nested Weston on X).

When will it be available in a release

I want to get this work into 4.11 as an experimental feature for multiple reasons. I wanted to have a build dependency to Wayland in 4.11 for quite some time. So that’s a nice excuse. Unfortunately feature freeze is approaching.

Of course I want to give users something to play with. We have talked about Wayland for such a long time and there is nothing to really see that we are walking the way. Last but not least that might be a rather important solution for Plasma Active as that hopefully allows to run on hardware where we currently would not get OpenGL. With libhybris we should be able to get KWin working with OpenGL and being an X11 compositor even if the driver doesn’t support X11. Though I have not tested this case yet and have no devices to play with. But I know a few people in the community who might be interested to play with that.

Tweet Buffer

Krita was the first painting application with an OpenGL accelerated canvas. We had that before Photoshop... Which also meant that the code was getting quite old fashioned. These days, life is supposed to be better. More flexible in any case. However, even though a 2D canvas is a simple thing, once you factor in rotation, zooming, panning and so on, the potential for bugs is quite big, and we've been fixing bugs for ages in the old code.

So I didn't want to throw that away, but have as clean and straightforward as possible a port from the old code to start with. The old code mostly looked like this (for painting the transparency checkers background):

KisCoordinatesConverter *converter = coordinatesConverter(); QTransform textureTransform; QTransform modelTransform; QRectF textureRect; QRectF modelRect; converter->getOpenGLCheckersInfo(&textureTransform, &modelTransform, &textureRect, &modelRect); KisConfig cfg; GLfloat checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast(cfg.checkSize()); textureTransform *= QTransform::fromScale(checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE, checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE); glMatrixMode(GL_PROJECTION); glLoadIdentity(); glViewport(0, 0, width(), height()); glOrtho(0, width(), height(), 0, NEAR_VAL, FAR_VAL); glMatrixMode(GL_TEXTURE); glLoadIdentity(); loadQTransform(textureTransform); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); loadQTransform(modelTransform); glBindTexture(GL_TEXTURE_2D, m_d->openGLImageTextures->backgroundTexture()); glEnable(GL_TEXTURE_2D); glBegin(GL_TRIANGLES); glTexCoord2f(textureRect.left(), textureRect.bottom()); glVertex2f(modelRect.left(), modelRect.bottom()); glTexCoord2f(textureRect.left(), textureRect.top()); glVertex2f(modelRect.left(), modelRect.top()); glTexCoord2f(textureRect.right(), textureRect.bottom()); glVertex2f(modelRect.right(), modelRect.bottom()); glTexCoord2f(textureRect.left(), textureRect.top()); glVertex2f(modelRect.left(), modelRect.top()); glTexCoord2f(textureRect.right(), textureRect.top(); glVertex2f(modelRect.right(), modelRect.top()); glTexCoord2f(textureRect.right(), textureRect.bottom()); glVertex2f(modelRect.right(), modelRect.bottom()); glEnd(); glBindTexture(GL_TEXTURE_2D, 0); glDisable(GL_TEXTURE_2D);

In other words, we set a projection, a transformation matrix for the texture and for the model/view and then start drawing the vertices. Pretty simple. I was rather surprised when I did not find any clear tutorial on converting code like this through google. I've read a bunch of modern opengl books and tutorials by now, and they pretty much all have the same order of explanation, the same things they emphasize and the same "advanced" topics. But I couldn't figure out how to draw my checkers or the tiles for my image. Yeah, I'm a linguist, not a mathematician, and I probable read these tutorials wrong or something.

In any case, after going through the Qt OpenGL examples, the tutorials on Wikibooks, the Red, Orange and Blue books, the Matt Gattis' notes on porting to WebGL and more confused questions and more confusing answers on Stack Overflow than I care to count, I finally got something that works, and is as straight a translation of the old code as possible.

Purists will cavil at my use of attribute arrays and glDrawArrays -- but the alternative, as far as I can tell, would be to redo all the matrix calculation and use matrices to place my tiles in the right location or to update and send new vertex buffer objects all the times. This works -- and in the future it might even be pretty.

So, for posterity, and because there might be others in the same spot as me (to wit, tasked with porting OpenGL 1.3 code to OpenGL ES 2.0 or OpenGL 3.1 without compatibility profile), here's a summary of my current code.

The vertex shader: uniform mat4 modelViewProjection; uniform mat4 textureMatrix; attribute highp vec4 a_vertexPosition; attribute mediump vec4 a_textureCoordinate; varying vec4 v_textureCoordinate; void main() { gl_Position = modelViewProjection * a_vertexPosition; v_textureCoordinate = textureMatrix * a_textureCoordinate; }

The fragment shader (needs to be expanded to handle color correction): uniform sampler2D texture0; varying mediump vec4 v_textureCoordinate; void main() { gl_FragColor = texture2D(texture0, v_textureCoordinate.st); }

And finally the code. The shader programs are all done using Qt's shader classes, and I don't show that code here -- it's in the calligra git repo anyway. KisCoordinatesConverter *converter = coordinatesConverter(); QTransform textureTransform; QTransform modelTransform; QRectF textureRect; QRectF modelRect; converter->getOpenGLCheckersInfo(&textureTransform, &modelTransform, &textureRect, &modelRect); // XXX: getting a config object every time we draw the checkers is bad for performance! KisConfig cfg; GLfloat checkSizeScale = KisOpenGLImageTextures::BACKGROUND_TEXTURE_CHECK_SIZE / static_cast(cfg.checkSize()); textureTransform *= QTransform::fromScale(checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE, checkSizeScale / KisOpenGLImageTextures::BACKGROUND_TEXTURE_SIZE); m_d->checkerShader->bind(); QMatrix4x4 projectionMatrix; projectionMatrix.setToIdentity(); projectionMatrix.ortho(0, width(), height(), 0, NEAR_VAL, FAR_VAL); // Set view/projection matrices QMatrix4x4 modelMatrix(modelTransform); modelMatrix.optimize(); modelMatrix = projectionMatrix * modelMatrix; m_d->checkerShader->setUniformValue("modelViewProjection", modelMatrix); QMatrix4x4 textureMatrix(textureTransform); m_d->checkerShader->setUniformValue("textureMatrix", textureMatrix); //Setup the geometry for rendering QVector vertices; vertices << QVector3D(modelRect.left(), modelRect.bottom(), 0.f) << QVector3D(modelRect.left(), modelRect.top(), 0.f) << QVector3D(modelRect.right(), modelRect.bottom(), 0.f) << QVector3D(modelRect.left(), modelRect.top(), 0.f) << QVector3D(modelRect.right(), modelRect.top(), 0.f) << QVector3D(modelRect.right(), modelRect.bottom(), 0.f); m_d->checkerShader->enableAttributeArray(PROGRAM_VERTEX_ATTRIBUTE); m_d->checkerShader->setAttributeArray(PROGRAM_VERTEX_ATTRIBUTE, vertices.constData()); QVector texCoords; texCoords << QVector2D(textureRect.left(), textureRect.bottom()) << QVector2D(textureRect.left(), textureRect.top()) << QVector2D(textureRect.right(), textureRect.bottom()) << QVector2D(textureRect.left(), textureRect.top()) << QVector2D(textureRect.right(), textureRect.top()) << QVector2D(textureRect.right(), textureRect.bottom()); m_d->checkerShader->enableAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE); m_d->checkerShader->setAttributeArray(PROGRAM_TEXCOORD_ATTRIBUTE, texCoords.constData()); // render checkers glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_d->openGLImageTextures->checkerTexture()); glDrawArrays(GL_TRIANGLES, 0, 6); glBindTexture(GL_TEXTURE_2D, 0); m_d->checkerShader->release();

For Krita, there are quite a few todo's left:

• Restore the opengl outline cursor -- now we use the qpainter one
• Render onto a framebuffer object so this code can be integrated in Krita Sketch
• Update the image texture tiles in a thread
• Update the projection in a thread
• Restore the colormanagement using OCIO
• Check whether it runs on Windows, OSX (and Android)
• Maybe move the layer composition to OpenGL using the GPUImage shader code?

Especially the testing on Windows is interesting, since the old opengl canvas never worked on Windows.

Hi there, while we've been working very hard on the next Amarok feature release, the 2.8, we also haven't forgot the majority of our users using the stable versions.

Welcome Amarok 2.7.1, a very close relative of 2.7.0 with just a couple of very important bug fixes. The 2.7.1 is also an opportunity for Arch Linux to package it correctly. :-)

Don't fear that we've made just 8 commits since 2.7.0. In fact, we've made over 300 by 25 different people! Look forward for better transcoding, ASX playlist and Opus audio format support, improved MusicBrainz tag guessing and improvements of existing features all over the place for Amarok 2.8.0.

Remember the 4.11 Soft Feature Freeze is in 7 days so try to get your features ready for merging as soon as possible. If you add your features to the Feature Plan you get two weeks more until Hard Feature Freeze. Even if you don't need those two weeks you should add them anyway since it really helps other teams like promo, Q/A, etc. to have the features listed in one place.

I stumbled across an old blog post of mine about using grep with more than one expression: in the old days I used -e several times, one for each new expression. But as stressed in the comments that way is neither convenient nor reliable on ll platforms. And I have developed as well, so today I usually use egrep if I need to grep for several expressions. Thus, here are some short notes about using it.

The multiple arguments you are searching for a passed to egrep separated by pipes. For example, if you want to grep the output of lspci for all audio and video controllers, the correct command is:

$ lspci|egrep -i 'audio|vga' 00:05.0 Audio device: NVIDIA Corporation MCP61 High Definition Audio (rev a2) 00:0d.0 VGA compatible controller: NVIDIA Corporation C61 [GeForce 6150SE nForce 430] (rev a2)

( Yes, I know, I write my blog post on pretty old hardware right now )

egrep does understand more than two expressions, so you can use the option like $STRING_1|$STRING_2|$STRING_3|.... But don’t forget to include the high tics ' in the command: these ensure that the pipe is used as a separator instead of being interpreted by your shell.

Filed under: Linux, Shell, Short Tip, Technology

Dear all digiKam fans and users!

digiKam team is proud to announce the 3.2.0 release of digiKam Software Collection. This version include a new album interface display mode named list-view. Icon view can be switched to a flat item list, where items can be sorted by properties columns as in a simple file manager. Columns can be customized to show file, image, metadata, or digiKam properties.

read more

Yesterday it was reported that Skype, owned by Microsoft these days, seems to automatically follow each exchanged https link. Besides the fact that this is a huge security and personal rights problem in its own it again shows how important it is to not trust a proprietary system.

The problem, skin deep

Heise reported yesterday that Skype follows https links which have been exchanged in chats on a regular basis. First and foremost, this is a privacy issue: it looks like Skype, and thus Microsoft, scans your chat history and acts based on these findings on a regular base. That cannot be explained by “security measures” or anything like it and is not acceptable. My personal data are mine, and Microsoft should not have anything to do with as long as there is no need!

Second, there is the security problem: imagine you are exchanging private links, or even links containing passwords and usernames for direct access (you shouldn’t, but sometimes you have to). Microsoft does follows these links -and therefore gains full access to all data hidden there. Imagine these are sensitive data (private or business), you have no idea what Microsoft is going to do with them.

Third, there is the disturbing part: Microsoft only follows the https links, only the encrypted URLs. If this action would be a security thing, they would surely follow the http links as well. So there must be another explanation – but which one? It is disturbing to know that Microsoft has a motivation to regularly follow links to specifically secured content.

The problem, profound

While these news are shocking, the root problem is not Skype or the behavior of Microsoft – I am pretty sure that their Licence Agreement will cover such actions. And it is most likely that others like WhatsApp, Facebook Chat or whatnot do behave in similar ways. So the actual problem is handing over all your data to a company which you have no inside to. You have no idea what they are doing, you have no control about it, and you cannot even be sure that nothing bad is done with it. Also, most vendors try to lock you in with your service, so that switching away from them is painfully due to used workflows, tools and social networks.

The solution

From my point of view, my personal perfect solution is hosting such sensitive services on my own. However, that cannot be a solution for everyone, and I for myself cannot provide for example the SLAs others need.

Thus I guess the best solution is to be conscious about what you do – and what the consequences are. Try to avoid proprietary solutions where possible. For example for chats, try to use open protocols like XMPP. Google Talk is a good example here: company based, but still using open protocols, they even push the development forward (Jingle, …). Or, if you upload files to web services, make sure you have local backup. Also, try not to upload sensitive data – if you have to, encrypt it beforehand. And if you use social networks, try to not depend on one of them too much, use cross posts for various services at the same time if possible.

And, last but not least: ask your service providers to establish transparency and rules for a responsible and acceptable usage of your data. After all, they depend on the users trust, and if enough users are requesting such changes, they will have to follow.

Filed under: Google, IM/VoIP, Microsoft, Politics, Security, Technology, Thoughts

In case you haven't heard about it, Colibri is an alternative to KDE Plasma notifications.

Colibri notifications are completely passive: when you move the mouse over them, they fade out and let you click the content behind them. They also have the handy ability to concatenate multiple notifications if they come from the same application (think about your friend who likes to press Enter every five words on IM...)

It has been a long time (2 years!) since I last touched Colibri code: mainly because it was working for me, so I spent my time on other projects. With the release of KDE SC 4.10, I noticed a problem though: there was no shadow behind the notification bubbles anymore.

This is fixed in 0.3.0. The nice thing about this fix is I was able to drop code I duplicated from Plasma internals by refactoring Colibri to use Plasma::Dialog. Less duplicated code should result in a more robust implementation, hopefully Colibri should be usable without patching for 2 more years :)

Another change I made was moving the project from Gitorious to git.kde.org, this brings you more translations.

You can get the source code from download.kde.org. Kubuntu 13.04 users can also get it from the Colibri PPA.

The Calligra team has released version 2.6.3, another bugfix release of the Calligra Suite, and Calligra Active. This release contains a number of important bug fixes to 2.6.2 and we recommend everybody to update.

Bugfixes in This Release

Here is an overview of the most important fixes. There are several others that are not mentioned here.

General:

• Fix crash in the Document Structure docker

Kexi:

• Fix look of the modern menu and tabbed toolbar for the bespin widget style

Try It Out

• The source code is available for download: calligra-2.6.3.tar.bz2. As far as we are aware, the following distributions package Calligra 2.6. This information will be updated when we get more details. In addition, many distributions will package and ship Calligra 2.6 as part of their standard set of applications.
• In Chakra Linux, Calligra is the default office suite so you don’t have to do anything at all to try out Calligra. Chakra aims to be a showcase Linux for the “Elegance of the Plasma Desktop” and other KDE software.
• Users of Ubuntu and Kubuntu are urged to try the daily snapshots prepared by Project Neon. Paste the following in a terminal window and you’ll find Calligra installed in /opt: sudo add-apt-repository ppa:neon/ppa \ && sudo apt-get update\ && sudo apt-get install project-neon-base \ project-neon-calligra \ project-neon-calligra-dbg

  You can run these packages by adding /opt/project-neon/bin to your PATH.

• Arch Linux provides Calligra packages in the [kde-unstable] repository.
• Fedora packages are available in the rawhide development repository (http://fedoraproject.org/wiki/Rawhide), and unofficial builds are available for prior releases from kde-unstable repository at http://kde-redhat.sourceforge.net/ .
• OpenSUSE Calligra packages for openSUSE 12.3 are available in repository http://download.opensuse.org/repositories/KDE:/UpdatedApps/openSUSE_12.3/. The latest KDE SC stable release also includes the new stable Calligra.
• Calligra FreeBSD ports are available in Area51.
• MS Windows installer will be available from KO GmbH.
• Mac OS X: We would welcome volunteers who want to build and publish packages for the Calligra Suite on OS X.

About Calligra

Calligra is part of the applications from the KDE community. See more information at the website http://www.calligra.org/.

Here are the bugs which were fixed in Dolphin for last week’s release:

• Aureliéns efforts to make our hover animation as good as possible were not over yet: one little bug remained after his recent fixes. For details, see git commit c3a7ba4e, review request 109960.
• Bug 316129: When entering a directory, load the icons for the visible icons first, rather than loading all icons in random order. See git commit 52a38ee9, review request 109843.
• Bug 317827: Fix possible crash when filtering items. See git commit 34d0ad72.
• Bug 316285: Fix crash in the accessibility code. See git commit f8bf2577.
• Bug 317772: Disable the non-working Find/Replace actions when renaming inline. See git commit a16562cd.
• Bug 193298: Make sure that the correct free space for the current device is shown when viewing a folder with a name whose beginning coincides with a mount point. See git commit 4f2ecbab, review request 110225.
• Bug 318942: When renaming multiple files, make sure that the “Rename” button is enabled if and only if there is exactly one connected sequence of ‘#’ symbols. See git commit cbb2a4cf, review request 110223.
• Bug 305734: Fix the problem that selected hidden items are hard to see with certain color schemes. See git commit 572513a1, review request 110164.
• Bug 302037: Prevent that the view URL changes unexpectedly when the Terminal Panel is enabled and the current path is a symbolic link to a directory. See git commit 2e123de9, review request 110233.

Thanks for providing patches, helpful analysis and testing proposed fixes: Aurélien Gâteau, David Faure, Emmanuel Pescosta, and Jekyll Wu.

Blog Tags: 

• News
• release
• planetkde

The Skrooge team is pleased to announce the release 1.7.1 of its popular personal finances management application. 

Bugfix & Enhancements:

• Fixed bug 319565: Bad performances on ubuntu 13.04
• Fixed bug 316604: Income and Expense widget on the dashboard does not respect suboperations in split operations
• Fixed bug 316796: Reports crash when closed normally
• Fixed bug 279967: When automatically started at login, Skrooge is always displayed on all desktops
• Fixed bug 319145: Multiple currency support still buggy
• Enhancement in Group Operations (allow grouping more than 2 operations, or already grouped operations)
• Hide internal properties in "Search & process", in operation page and in the function "Add property"
• Enhancement in QIF import with mixed date format
• Correction: The advice action "Remove groups with only one operation" does not remove the operation but the group
• Better performances in kmymoney import and all other imports
• Skroogeconvert now supports files without path (example: skroogeconvert -in t.csv -out t.kmy)
• Better performances of skroogeconvert in case of skg import or export
• Global performances gains by using the right index on unit table
• Renamed "Undo document" to "Revert document"
• Reduce the number of messages when using backend import
• Better support of import/export with url
• Better merging of operations in QIF import
• Monthly reports and main page use the general font of KDE

New Features

• New file format (AFB120 CFONB) can be imported
• Open report from dashboard widgets
• More modification functions in "Search & Process" panel for Payee, Account, Tracker
• New "capitalize" function in "Search & Process" panel
• New attributes "Unit" and "Transfer" in "Search & Process" panel
• All update functions are now available for properties in "Search & Process" panel
• New icon in tab bar to create new page
• More attributes in line and column in reports (graph)
• Abillty to force the date format for qif and csv imports
• More functions in tool menu
• More tips of the days
• Dispay option "Hide pointed operations" in operation page
• Ability to group tables on user defined properties
• Ability to group tables on hidden column
• Addition of the new currency "Bitcoin" with automatic download of the rate
• In dashboard and monthly report, banks can be clicked to open corresponding operations
• In report, the graph correction can be done by multiply or divide

Get it, Try it, Love it...

Grab Skrooge from your distro's packaging system. If it is not yet included in repositories, go get it from our website, and bug your favorite distro for inclusion.

Get Involved

To enhance Skrooge, we need you ! There are many ways you can help us:

• Submit bug reports
• Discuss on the KDE forum
• Contact us, give us your ideas, explain us where we can improve...
• Can you design good interfaces ? Can you code ? Have webmaster skills ? Are you a billionaire looking for a worthy investment ? We will be very pleased in welcoming you in the skrooge team, contact us !

A few month have past, this my last WebMiner update. In the meantime I finished my Master Thesis, moved to a new location and started my new job. Perfect time to release a new version with the changes I have made since.

The Nepomuk WebMiner 0.6 adds beside several bugfixes:

• User changeable regular expression for the filename parsing.
• Removed its own and reuse the Nepomuk internal fileindexing to get id3 tags and other file metadata.
• Add whitelist for automatic web search. You might like to lookup the folder with your publication pdfs but not your private documents. Or the network share with your tvshows, but not your private family videos. This works on top of the Nepomuk whitelist. So you Nepomuk can index these files, but not all of them will be websearched.
• Instead of the dull treeview that shows the raw fetched metadata, you can now see and edit the metadata in several fancy edit fields.

 

 

 


You can find the latest release on projects.kde.org or the tarball on kde-apps.org.
Even though I wanted to get this into KDE SC 4.11, I doubt this is going to happen. Soft feature freeze is around the corner and I don't feel comfortable enough to let this be part of SC and annoy all users with this service yet. There are still a lot of usability problems I like to have solved properly before this can be part of of any KDE installation.

So please test the latest release and report any errors back to me.

Finally I have merged my Google Summer of Code work for KStars and the new feature called “What’s Interesting…” is on master branch. This feature suggests “interesting” sky-objects to users to view. Whether a sky-object is interesting or not depends on the night-sky conditions and the equipment availability. Hopefully this feature would prove useful for beginner astronomers. Although this merge has taken a long time, I never felt like all that work could go waste. Thanks to Akarsh and Rafal for helping me throughout.

While a lot of polishing has been done, I’m sure there is always room for improvement. I’m therefore awaiting feedback from users of KStars regarding any unnoticed bugs or feature requests.

Cheers!

Today when going through the list of Google+ communities I saw a message in a Linux G+ community that links to a blog post in Sprial Linear that talks about GNOME developers ignoring user requests. This is heartbreaking.

The incident commenced when a user Eduard Valiauka reported this bug in GNOME’s bugzilla. A feature in GNOME 3.6′s GNOME Terminal (background configuration tab in Profile Preferences) is missing in GNOME 3.8. He described the problem with some detail and asked the GNOME Terminal developers to add back the feature in later GNOME releases.

The conflict started when Christian Persch, a GNOME Terminal developer, simply replied “No.” and marked the bug as “Resolved” and “Won’t fix”.

This is a serious improper repsonse. If one developer wants to object to this feature, he can explain it with reasons that will please the bug reporter and other users. A “No.” will make users confused as to why this feature should removed at the first place, let alone whether it should be re-added. Developers shouldn’t shut the conversation at once. If a lot of users agree that this feature should be included, there is no good reason to object.

Many users then left a comment on the bugzilla page to support this proposal, and most of them argued that this feature is a major one. Some even thought that GNOME is reducing features too much.

But at comment #40 GNOME Developer and Bugzilla admin Olav Vitters responded by threatening that all users who left a comment shall be banned from the Bugzilla.

Why? Users HAVE the right to make feature requests and support proposals. This isn’t trolling. This is just a way to make their favourite desktop environment better. And the developers are closing their ears.

If you are a developer, ALWAYS listen to your application/operating system/kernel’s feedback. They are the key to your success, they are the gold to your code.

So, don’t deny other’s feedback or bugs early, they actually help.