17 Apr 2015

feedPlanet KDE

What happened in Toulouse?

… a KDE PIM sprint happened in Toulouse! And what happened during that sprint? Well, read this wholly incomplete report!

Let's start with the most important part: we decided what to do next! On the last PIM sprint in Munich in November when Christian and Aaron introduced their new concept for next version of Akonadi, we decided to refocus all our efforts on working on that which meant switching to maintenance mode of KDE PIM for a very long time and then coming back with a big boom. In Toulouse we discussed this plan again and decided that it will be much better for the project and for the users as well if we continue active development of KDE PIM instead of focusing exclusively on the "next big thing" and take the one-step-at-the-time approach. So what does that mean?

We will aim towards releasing KF5-based KDE PIM in August as part of KDE Applications 15.08. After that we will be working on fixing bugs, improving the current code and adding new features like normally, while at the same time preparing the code base for migration to Akonadi 2 (currently we call it Akonadi Next but I think eventually it will become "2"). I will probably write a separate technical blog post on what those "preparations" mean. In the meantime Christian will be working from the other side on Akonadi 2 and eventually both projects should meet "in the middle", where we simply swap the Akonadi 1 backend with the Akonadi 2 backend and ship next version. So instead of one "big boom" release where we would switch to Qt 5 and Akonadi 2 at the same time we do it step-by-step, causing as little disruption to user experience as possible and allowing for active development of the project. In other words WIN-WIN-WIN situation for users, devs and the KDE PIM project.

I'm currently running the entire KDE PIM from git master (so KF5-based) and I must say that everything works very well so far. There are some regression against the KDE 4 version but nothing we couldn't handle. If you like to use bleeding-edge versions of PIM feel free to update and help us finding (and fixing) regressions (just be careful not to bleed to death ;-)).

Another discussion we had is closely related to the 15.08 release. KDE PIM is a very huge code base, but the active development team is very small. Even with the incredible Laurent Montel on our side it's still not enough to keep actively maintaining all of the KDE PIM (yes, it's THAT huge ;-)). So we had to make a tough decision: some parts of KDE PIM have to die, at least until a new maintainer steps up, and some will move to extragear and will live their own lives there. What we release as part of KDE Applications 15.08 I call KDE PIM Core and it consists of the core PIM applications: KMail, KOrganizer, KAddressbook, Kleopatra, KNotes and Kontact. If your favorite PIM app is not in the list you can volunteer as a maintainer and help us make it part of the core again. We believe that in this case quality is more important than quantity and this is the trade-off that will allow us to make the next release of PIM the best one to date ;-).

Still related to the release is also reorganization of our repos, as we have some more splitting and indeed some merging ahead of us but we'll post an announcement once everything is discussed and agreed upon.

Thanks to Christian's hard work most of the changes that Kolab did in their fork of KDE PIM has been upstreamed during the sprint. There are some very nice optimizations and performance improvements for Akonadi included (among other things), so indeed the next release will be a really shiny one and there's a lot to look forward to.

Vishesh brought up the topic of our bug count situation. We all realize the sad state of our PIM bugs and we talked a bit about re-organizing and cleaning up our bug tracker. The clean up part has already begun as Laurent with Vishesh have mass-closed over 850 old KMail 1 bugs during the sprint to make it at least a little easier to get through the rest. Regarding the re-organization I still have to send a mail about it but a short summary would be that we want to remove bugzilla components and close bugs for the apps we decided to discontinue and maybe do a few more clean up rounds for the existing bugs.

I'm sure I've forgotten something because much more happened during the sprint but let's just say I'm leaving some topics for others to blog about ;-).

Huge thank you to Franck Arrecot and Kevin Ottens for taking care of us and securing the venue for the sprint! All in all it was a great sprint and I'm happy to say that we are back on track to dominate the world of PIM.

The only disappointment of the entire sprint was my failure to acquire a French beer. I managed to try Belgian, Spanish, Mexican and Argentinian beer but they did not serve any French beer anywhere. Either there's no such thing or it must be really bad…:-)

KDE PIM Sprint in Toulouse

We had a great dinner with the local KDE people on Saturday. Also a prove that Laurent is a real person :-D

17 Apr 2015 9:54pm GMT

KActivities on KDE's Phabricator

If you haven't heard, there are a few KDE projects testing Phabricator for patch review and project management.

KActivities are amongst those.

So, from now on, if you want to provide patches, you are advised to do that through http://phabricator.kde.org/ and the Arcanist tool instead of the ReviewBoard.

We are also going to organize our work tasks on Phabricator instead of todo.kde.org.

The ultimate goal is to test whether Phabricator is a viable alternative to a few of our services.


17 Apr 2015 8:08pm GMT

Latest KDevelop plugin improvements

Hi there!
Let's review what I've done to KDevelop's kdev-cppcheck and kdev-valgrind plugins lately.

JSONized kdev-cppcheck and kdev-valgrind

This is fairly straightfoward: These plugins were still using the old .desktop plugin manifest files. Now they are using the embedded JSON manifests. This isn't something user visible, but it's needed as the old .desktop method is now deprecated.

Added the number of calls to the callgrind output of kdev-valgrind

Until now the callgrind output has only shown the IR and Inclusive IR fields. Now is shows the number of calls as well. Take a look at the pictures!


Reorganized the output of memcheck in kdev-valgrind

Until now kdev-valgrind's memcheck output unfortunately didn't show enough of the callstacks to be really useful. You couldn't see where the problem exactly occured, or where it was stemming from! Now it shows the full backtrace + the auxilliary trace as well, so you can see what actually causes the problems. See the pictures!


17 Apr 2015 2:22pm GMT

Like Braindump? Adopt it for the Qt5/KF5 port!

As you might know, Calligra now also started porting to Qt5/KF5. We are currently reaching the end of stage 1, where everything is readded to the build ("links and installs? done!"), with next stage then to fix anything that broke or regressed (see screenshots!1!).

Just, we also now see that noone in the current set of active Calligra developers has enough love left for Braindump, the notetaking and mindmapping application from the creativity and productivity suite Calligra.

So as it stands Braindump would be left behind during the porting phase and be discontinued, for now at least :(


Braindump is a nice example for the flexibility of the Calligra architecture, where objects are implemented by so called "Shape" plugins, which then are available to any application supporting "Shape"s in general. The actual code of Braindump itself is centered around the concept of whiteboards with unlimited canvas, where one can drop all possible kind of objects (the "shapes") and then note their relations. With automated saving in the background, no need for any "Save" button.

See this older video to get an idea of the possibilities:

Cyrille, who has developed Braindump, says:

"I am still interested in the application itself, but what it really needs is a better user interaction, and flake [name of the Shape system, ed.] is not flexible enough to provide it, and I don't have the energy to make it flexible enough".

He and the rest of the Calligra team will happily assist someone who ideally already uses Braindump and now would like to overtake the future development for the Qt5/KF5 based version, to enhance their workhorse. And the porting time is a good time to get to know the current system: for the first Qt5/KF5 based Calligra release, 3.0, we are concentrating on a pure port, so no new features or refactoring (ignore the exceptions ;) ), only minimal changes. And envisions the options after the port/3.0: e.g. get Braindump to run on your Android or Sailfish OS tablet! Connect it to syncing servers like ownCloud! Or whatever would enhance your Braindump usage.
And all done while enjoying the synergy effects from the shared libs and plugins of the Calligra suite.

Your chance, now :) Don't hesitate too long, as Braindump will bitrot more and more, once the 3.0 release is done and the Calligra libs will see more refactoring.

Find us in the channel #calligra on irc.freenode.net, or join the mailing-list calligra-devel@kde.org.

17 Apr 2015 9:23am GMT

16 Apr 2015

feedPlanet KDE

Jekyll: Moving away from WordPress

In the beginning, I used Blogger. But it was limiting, and had its share of problems.

After a while, I decided to use my own host (ivan.fomentgroup.org) and switch to a mixture of Folite (a small CMS I wrote for my other sites) and WordPress (for the blog section).

This combination has provided my online presence (to use the marketing-speak :) ) since 2009. During that time, WordPress started becoming a huge beast that I had to reinstall quite a few times, and each time to triage which plugins broke it. WP has streamlined its interface, the admin section and everything, but it is quite difficult to manage if you need to dive into its code base.

So I decided to make a change. I decided to switch to a new domain (cukic.co) and to new blogging software.

I looked into Ghost (due to Aaron's recent switch from Blogger to Ghost), Anchor, Wardrobe and a few other simpler blogging solutions. They seemed nice, but either needed Node.js, or something similar that is not supported by my hosting provider; or they just did not work for some reason.

Then I found Jekyll.

Totally unrelated: BBC's Jekyll, awesome TV show

Jekyll is a simple website generator which allows you to create templates, different page layouts with all the power of Ruby and Liquid, to write content in Markdown (and others), and it generates static html files from those that you then just need to upload to the server.


16 Apr 2015 10:54pm GMT

Another Video Review


Kubuntu 15.04 Review - Looking Fantastic

16 Apr 2015 7:24pm GMT

Kdenlive 15.04.0 released

The Kdenlive team is happy to announce the release of Kdenlive 15.04.0. While there are very few new features in this release, it is a huge step towards a bright future!

Kdenlive is now an official KDE application

This has several implications:

  • We fully benefit from KDE's infrastructure, which means less worries for the developpers.
  • We stick to KDE Applications release schedule, which means one bugfix release every month, one feature improved version every 4 months. That's a big change from the previous random release every year or so. This is possible because the KDE team takes care of the release, not our small dev team, so a big thank you to KDE.
  • We now use KDE's bugtacker at https://bugs.kde.org.
  • We benefit from KDE's build servers and team, which means that we might in the future have Mac OS and Windows versions without too much efforts from the dev team.
  • We can now be part of the Google Summer Of Code.
  • We have adopted the KDE Applications numbering scheme. From now on, Kdenlive versions will be numbered with Year.Month.Bugfix. That explains the 15.04.0 version.
  • Every KDE contributor can help us improve Kdenlive.

What changes right now for Kdenlive users

Most of the work for this release was porting the code to Qt5 and KDE Frameworks 5 (KF5). While users will not see direct benefit, this makes us ready for the next big steps. Changes in this version include:

  • Since we are now based on Qt5/KF5, you NEED KDE Frameworks 5 to run Kdenlive.
  • Fixed video stabilization
  • Auto save new projects
  • Download new render profile feature fixed

You can download the source code, binary packages for your distro should hopefully be prepared by distibution packagers.

What will change in the near future

While Kdenlive 15.04.0 is mostly a Qt5/KF5 port, we have many new features/improvements in preparation for the 15.08.0 release. Here are some of the features that we are currently working on:

  • Finally integrate some of Till Theato's work resulting from our Indiegogo campain. It took us 2.5 years but we are finally merging parts of the refactoring effort.
  • Use OpenGL for the video display, bringing back experimental GPU display and effects
  • Add effects to Project clips: for example, add color correction to the clip in the Project Bin. Every instance of the clip that is then used in timeline will have that color correction.
  • Cleaning the code to make it easier to understand.

That's it for today, I probably forgot many things but that might be an excuse to blog more often :).

16 Apr 2015 5:58pm GMT

iOS video rendering

The multimedia layer in Qt contains various possibilities for including streaming video in your QtQuick applications - most commonly there's the Video element, which you include in your QML interface, specifying the source URL, playback options and so on.

Unfortunately, on iOS you'll discover a limitation: the backend for QtMultimedia only supports window-level integration. In practice this means any QtQuick items supposed to be positioned on top of the video, in fact appear behind it. At KDAB we have several clients who want to show customised playback interfaces on top of the video stream, with application-specific data, and of course taking advantage of all the visual power and flexibility of QtQuick.

Since Qt is based around the idea of people contributing and collaborating, we decided to investigate the work involved in fixing this limitation, and we're pleased to say that we found a high-performance solution which will be included in Qt 5.5. The most complex piece of the problem, getting hardware-decoded video frames into an OpenGL texture on the GPU, is handled for us by a family of CoreVideo APIs, and an object called a CVOpenGLESTextureCache. This interfaces to the iOS DRM and hardware-accelerated video decoding layers, to give us video frames in a format we can use. Even better, the layer takes care of delivering frames with colour-space conversion from YUV (the standard for video) into the RGB space we need for QtQuick rendering.

Here's the result: Qt Quick, Controls and graphical effects on top of video, on iOS:


Of course, interfacing the CoreVideo classes into the Qt Multimedia code required some experimentation, especially to correctly manage the lifetime of the video frames. Since each frame is consuming GPU texture memory, it's important we are able to know when they can be safely discarded. Fortunately the existing window-based implementation of video on iOS already provides the OpenGL context needed to initialise the texture cache.

In the end we're delighted with the result. In particular there are no intermediate copies of the video frame data between what CoreVideo produces and what is passed to the scene-graph for display, so this solution should be suitable for HD video without excessive power consumption.

The post iOS video rendering appeared first on KDAB.

16 Apr 2015 2:47pm GMT

Qt on Android Episode 6

In the last Qt on Android episode we learned the basics of JNI on Android in a Qt way. In this episode I'd like to focus on tools that will help us to be more productive when we extend our Qt on Android applications.

Using an external IDE to manage Java files.

Sadly, the Java support in Qt Creator is very limited, and in order to be productive we need to use an external IDE to easily extend and debug the Java part of our application. Android provides two powerful IDEs:

This article will focus only on Android Studio.

But before we talk more about tools, let's check the Android specific files which are part of your project.

As I told you in the first article, any Qt on Android application has two big parts:

All the Android specific files are needed to build your android package (as we learned in episode 3). But where are all these files? Why are only a few files copied to your sources when you press "Create templates" button (as shown in the next image)? QTC_CopyAndroidTemplates_o

Well, Java, Ministro service .aidl files and some resources are kept "hidden" in your Qt SDK. We don't want to copy them to your source tree for two reasons:

Before Qt 5.4 it was quite complicated to extend the Java part of your application, mostly because you could not use an external IDE (Eclipse) in a decent way (e.g. with syntax highlighting, code-completion, code-refactoring, etc.). In order to get these goodies you had to manually copy all the Java files from Qt SDK installation folder to your application source folder, but as I said, we don't want you to do that and the only way to do it was to copy them locally and not add them to your SCM…

But starting with Qt 5.4. the situation changed when I added Gradle support to Qt 5.4 and to Qt Creator 3.3. Gradle is the new recommended android build system which is used by Android Studio. Using Gradle we can keep all these files hidden and still give you all the goodies that you expect from a 21st century IDE. So, if you are planning to extend your Java part of your application, it is highly recommended to Copy the Gradle files to Android directory as shown in the next image: QTC_CopyAndroidTemplatesCopyGradle_o

Besides the AndroidManifest.xml and res/values/libs.xml files, the wizard will copy a few more:

build.gradle is very important, it allows you to easily add dependencies to your project.

E.g. to add PlayServices to your application you just need to add:

dependencies {
    compile 'com.google.android.gms:play-services:7.0.0'

to build.gradle, check this page for more info on this matter.

Now let's see how to use Android Studio with Qt:

Android Studio will be used only to:

Android Studio will NOT be used to run your Qt application, you still need to use Qt Creator for that job!

Let's take a look on how to import the Java part of your Qt application and how to debug it.

The import step is very easy: you just need to Open the existing build.gradle project file. Check the following image: AndroidStudio_OpenProject_o

Warning: Qt 5.4.0 users should upgrade their gradle files using Qt 5.4.1 or later (press again Create templates button and overwrite only gradle files). This step is needed because Qt 5.4.0 uses an old Gradle plugin and, after we released it, Google, as usual, broke the compatibility with older Gradle plugins and Android Studio doesn't import Qt 5.4.0 projects.

The last thing we are going to learn today is how to debug the Java part using Android Studio. You need to take the following steps:

After the last step, your application will be stopped by Android Studio when it hits first breakpoint.The problem comes when we need to start the debugging very early. To do that we are going to use the old fashioned sleep trick.

This is how our custom onCreate function looks:

public void onCreate(Bundle savedInstanceState)
    try {
    } catch (InterruptedException e) {

    // ....

Now your application waits 10 seconds after it starts and you should have enough time to select it and attach the java debugger.

Now that we have learned the basics of the JNI and how to use external tools to make la vie en rose (or la dolce vita), in the next article we will talk about Qt on Android apps architecture: how to extend the Java part of your application using a real life example to show how to correctly do safe calls from Qt thread to Android UI thread and vice-versa.

The post Qt on Android Episode 6 appeared first on KDAB.

16 Apr 2015 2:45pm GMT

A Purpose for everything

When we were porting Kamoso to Qt5/KF5, at some point I realized that it was about time we came up with whatever we'd want to do with sharing. Kipi is definitely an interesting technology, but no matter how I looked at it I found that it missed an iteration in the concept. In some aspects it's very specific, in some others very broad. In fact, I already tried to improve it, back in 2009.
My conclusion was that I wanted to take a step back and re-think what I wanted because I don't think it's just about images and it's not even just about Importing and Exporting.

This took me a while to figure out and it's probably not ready yet, but since I needed something anyway I decided to just go for it.


The idea is that at some point when developing an application you'll need to fulfill different purposes (or desires, as some like calling it). At this point we'll want to integrate the possibility of providing an action with all the information needed to fulfill it.

This purpose will have different fulfillment propositions, which we'll need to provide a list with the alternatives and then be able to go for the one the user prefers.

Example 1

In Gwenview we want to be able to share the currently displayed image. To do so, we'll get a toolbar button that on click we'll get the 2 more likely alternatives and a "More…" option that will open a dialog that lists all the possibilities.

With all the provided information, we should be able to perform the export with minimal and integrated configuration. The different alternatives could be exporting to imgur, saving the file locally, upload to my ownCloud or my Facebook. For this, note that any configuration will seldom be needed.

Example 2

We're reviewing code in KDevelop and we want to tell on someone we messed up. KDevelop can integrate the "Call" purpose that will propose us all the different ways to get in touch of the disaster perpetrator.

Example 3

The QuickShare plasmoid has a patch file dropped on. We receive the alternatives which can have any mime type: text files, binary files and any specific format (such as text/x-patch or text/markdown).

Example 4

An application wants to show us a location in a map. Instead forcing into some implementation, it will request Purpose to show a latitude and longitude and the user will decide where to check it. Alternatives could be OpenStreet Map, Google Maps and Marble.


I came up with a small proof of concept to be able to start getting things working and I even adopted it on a couple of projects. It's working well but I'm still a bit afraid of committing to an API. As a first step, I'm here explaining it for you all.

At the moment the API is really simple, it consists of 3 C++ classes:

Then there's some QtQuick components built on top that simplify the integration on QML applications. We should get some QtWidgets components as well, as soon as we have to integrate it on a QtWidgets-based application.

The AlternativesModel will receive a PluginType string which defines what kind of plugin will be used and the input data. The plugin type will define what information needs to be provided and what output will be received. Then the model will be populated with all the plugins with the said PluginType. The plugins will be able to specify a set of constraints, so the model can filter them out in case they're not a good fit, and a set of configuration variables. These configuration variables are required to run the plugin and if they're not provided, the application will need to show the user interface provided by the plugin, which is implemented through a QtQuick file, for now.

For some more precise information, here's

TextField { id: url }

  pluginType: "Export"
  inputData: {
    mimeType: 'text/plain',
    urls: [url.text]

  onFinished: {
    console.log("Done", output.url)
    if (error!=0) {
      console.log("error:", errorString)

Where are we?

It can be used now. It's already integrated in the QuickShare plasmoid in kdeplasma-addons and in Kamoso which should be released eventually. Still, I'd like to see other use-cases being implemented and developed. The biggest void I see is plugins: getting Google+, Twitter, Facebook, ownCloud should be easy but needs to be done. If somebody is knowledgeable about such API's and is interested in KDE applications integrating them, please step forward!

Additionally, if you think your application could use some purposes or that you have an idea of a new purpose that will change humanity, don't hesitate to get in touch. We'll change it together! \o/

Now here's a screencast of the work in progress (especially the UI, eh..)

PS: Video uploaded using Purpose as well!

16 Apr 2015 2:27pm GMT

15 Apr 2015

feedPlanet KDE

OMG! UBUNTU! Previews KDE Plasma 5.3 Beta

Their review highlights the improved Power Management features, because they are hoping to distract their readers from the QR code ;-)


15 Apr 2015 1:06pm GMT

Tomahawk 0.8.4

Tomahawk 0.8.4 is out! For Windows and OS X this will be our last Qt4-based release. Support for Qt4 in git-master won't be dropped unless there is a compelling reason to do so, but building with Qt5 is now recommended and the new default. If you prefer to stick to the old Qt version, simply run cmake with -DBUILD_WITH_QT4=ON as an additional argument. At the same time we also started using features of C++11, which is now a requirement to build Tomahawk's master branch. Qt on OS X This means our next major release will be Qt5-based across all platforms, and the Linux and Windows nightlies already work...

15 Apr 2015 6:20am GMT

14 Apr 2015

feedPlanet KDE

Not just a review, but a video review, of Kubuntu Vivid

AJ Reissig


posts a video review of Kubuntu 15.04 as we get close to the announcement.

14 Apr 2015 1:09pm GMT

13 Apr 2015

feedPlanet KDE

LabPlot 2.0.2 released

We are glad to announce the release of the next version of LabPlot - 2.0.2, which can be downloaded here. Though we've only increased the minor number (we're still in the process of completing the 2D-plotting part), there was a lot of development done for this release. Many new features were implemented and the responsiveness of the application was improved in many cases.

With this release we started to implement what is usually named as "data analysis" in plotting software and we'll add new analysis features gradually in the next releases. We hope to quickly close the gap in this area to the feature set that was available in the old (kde3-based) version of LabPlot. The first step in this direction is linear and non-linear regression analysis available now in LabPlot. Creating a fit to data is easy - given the data sets in a spreadsheet, one adds a new "xy-curve from a fit to data" to a plot and provides the data to be fitted and the mathematical model. Here, several predefined fit models are provided. User-defined models are also possible. The fit to the data is shown as the curve in the plot once the calculation is done and the goodness of the fit is documented with the help several parameters like sum of squared errors etc.

non-linear regression analysis

With version 2.0.2 2D-curves defined by mathematical equations in cartesian and polar coordinates or via a parametric equation can be plotted. This is done just by adding a "xy equation curve" to the plot and by providing the mathematical expression and ranges defining that curve.

curve defined by a mathematical equation

The text field for the mathematical equation helps the user with syntax completion and highlighting. Two dialogs where all supported mathematical and physical constants and functions help further with the definition of mathematical expressions.
functions dialog
constants dialog

In addition to the two big new features described above, many smaller features and improvements were implemented.

Besides fixed worksheet sizes (predefined sizes like A4 etc. or user-defined), complete view size for the worksheet can be used. In this case the worksheet fills the complete window area availble. All sizes of the worksheet and its children are automatically adjusted if the application window is resized.

Different types of arrows can now be drawn for the axis.
arrow types

Though the number and the position of axes in a plot in LabPlot is arbitrary and can be easily controlled and changed by the user, four templates were provided for the four plot types most commonly used - boxed plot with four axes, box plot with two axes, plot with two centered axes (placed at the center of the plot) and plot with two axis crossing at the origin point (0,0). These templates are reachable via the tool bar or the context menu of the worksheet.

Several worksheet objects like plot area, plot legend etc. can draw now rounded borders.
rounded corners

Further smaller features implemented in LabPlot 2.0.2 are new formats for axis tick labels - "powers of 10″, "powers of 2″ and "powers of e" - and three additional types for drop lines in a xy-curve - "zero baseline", "min baseline" and "max baseline". The new drop line typ "zero baseline" e.g. is usefull when plotting residuals stemming from a fit where one wants to visualize the absolute error (the distance to the zero baseline) of the fit for each single data point like in the plot with the fit to data shown above.

The navigation through the plotted data was improved. The user can zoom into the shown data with the mouse via "select region and zoom in", "select x-region and zoom in", "select y-region and zoom in" mouse modes. Also, simultaneous zooming and navigation accross multiple plots is possible now.

The spreadsheet - the central object in LabPlot providing data - was extended by several methods for data generation. A column can be filled with a constant value provided by the user or with equidistant values. Lesser trivial use-cases for data generation are filling of columns with uniform and non-uniform random numbers, whereas several distributions are available for the second case, and filling of columns with values of a mathematical function.
generate random values
generate function values

Data in a spreadsheet can be exported now to a text file. The export of a worksheet to a PNG-image was extended by an option for the image resolution.

Finally, many improvements regarding the performance of the application were done. The import of ascii-data into a spreadsheet gained a huge speedup. Also, faster plotting of bigger data is now possible with LabPlot. Save and load of projects is now much faster then in the previous version.

Thanks to the KDE translators, translations are available for Bosnian, Brazilian Portuguese, English, Dutch, French, German, Polish, Portuguese, Spanish, Swedish and Ukrainian (and partially for couple of other languages).

This is the fist release of LabPlot being part of KDE. I want to thank to everybody who helped with the transition to the KDE-infrastructure. Especial kudos goes to Ben Cooksley an to Yuri Chornoivan who introduced me into many different topics regarding the KDE infrastructure (git, translations, documentation etc.) in private communications, to Andreas Cord-Landwehr who prepared the new site on edu.kde.org and to Andreas Kainz who completed the oxygen icons used in LabPlot and who created also the breeze icon set for LabPlot.

Also, I want to thank here Matthias Mailänder who continues to help with testing of the release candidates, checking the readiness of the tarball to be rpm-packaged and who prepares packages for openSUSE.

13 Apr 2015 9:11pm GMT

You can come to the Randa Meetings 2015 – Please register now

The dates for the sixth edition of the Randa Meetings are set: Sunday, 6th to Sunday 13th of September 2015. The first Sunday will be the day of arrival and the last Sunday accordingly the day of departure.

So what about you? If you know about Qt and touch gesture support, want to bring your KDE application to Android and Co, plan to work on KDE infrastructure for mobile systems, are a UI or UX designer for mobile and touch interfaces, want to make your software more accessible or just want to work on your already ported KDE application please register as soon as possible on our Sprints page.

The registration is open until the 13th of May 2015. Please add your estimated travel cost and what you plan to work on in Randa this September. You don't need to include any accommodation costs as we organize this for you (see the Randa Meetings wiki page for further information about the building). After this date we will present a budget and work on a fundraiser (together with you) to make it possible for as many people as possible to come to Randa.

If there are any questions or further ideas don't hesitate to contact me via email or on freenode.net IRC in #randa.

flattr this!

13 Apr 2015 7:29pm GMT

[Short Tip] Use host names for Docker links


Whenever you link Docker containers together, the question comes up how to access services provided by the linked container: the actual IP address of the container is not static and cannot be guessed beforehand. Sure, the IP address can be looked up by the environment variables ($ env), but not all programs can be modfied to understand these variables. This is even more true for containers which you receive from the Docker registry.

Thus the quickest way is to define a host name along the docker run. The container can be reached afterwards via that exact name.

$ docker run --hostname=db-container -d postgres
$ docker run -it --link db:dbtestlink centos /bin/bash
# ping db-container
PING dbtestlink ( 56(84) bytes of data.
64 bytes from dbtestlink ( icmp_seq=1 ttl=64 time=0.178 ms

Filed under: Debian, Fedora, Linux, Shell, Short Tip, Technology, Virtualization

13 Apr 2015 3:33pm GMT