Unlocking wallet during startup

While setting up plasma5 I found a solution for something that had been bothering me forever. Basically, while session management is restoring all windows, the wallet isn't open yet, so if the wallet is needed to get online (wifi password), all the apps being restored (in my case, about 20 konqueror windows) have no networking yet and just show error pages.
I had to be there during startup and type fast to unlock the wallet before the apps needed it.


New Plasma Task Manager backend: Faster, better, Wayland

During the last several months, I've been rewriting the backend for Plasma's Task Manager, the strip of launchers and windows embedded into the panel at the bottom of the screen.


Compiling all of Qt5, KF5, Plasma5, kdepim5, apps...

I see a very high value in compiling my own Qt, and on top of it all the KDE-made software that I use. This makes it very easy to fix bugs and add improvements to the software I use on a day to day basis. Nowadays I think many developers use distro packages for Qt or KF5 or even the whole environment except for the one app they're working on, but in my opinion this leads to "silo" thinking, with workarounds in upper layers rather than fixing issues at the right place.

So, here's a working and easy recipe for compiling all the Qt-based software you use.


What we do

Earlier this week, the loved one of a man I used to babysit was pushed into the path of an oncoming subway train car, by a stranger, and soon after died of their injuries.

While the death seems random, even cruelly so, it's one of many like it: Every year, people die on Berlin's various railways. Across Germany hundreds do, many of them similarly at metro train stations.

When disaster strikes, my thoughts soon dwell on analysis and prevention. For this particular case a well-demonstrated solution already exists: Platform screen doors, which I strongly hope the Berlin subway will eventually be retrofitted with.

As engineers, we deal in the makeup of the world all of us collectively inhabit. We help make and hammer away at the stuff of civilization.

We should all be offended by ill effects that may be prevented by means of better engineering. Our labor facilitates culture, but it's also on us to keep culture and its agents - people - safe.

It feels good that we enjoy many opportunities to act on our responsibility: Pick what we work on, weigh our concerns well, work diligently and pass on our knowledge. Make better engineering more affordable and available in this way.

This is true for any application of civil engineering, like a railway system, but just as much for any software system that users commute their thoughts and concerns through, if not their bodies.


Announcement: Marble ships the oldest existent historic Globe

Today I have the pleasure to announce that Marble is the first popular virtual globe that ships and visualizes the Behaim Globe. The Behaim Globe is the oldest surviving terrestrial globe on earth. It was created between 1492 and 1493 - yes at the same time when Christopher Columbus made his first voyage towards the west and "discovered" America.


Konsole's new "Manage Profiles" Configure dialog

One of the goals I've had with Konsole was to combine all the configure dialogs: 1) Configure Konsole; 2) Manage Profiles; 3) Edit Profile. Currently, in the branch config_dialog, the Manage Profiles is now combined with the main Configure dialog. The only downside is that the Konsole part can't open the Manage Profiles dialog. If and when the Edit Profile gets combined, I'll have to make sure the parts can open those dialogs.


GCI 2014 and Grand Prize Trip

Many pre-university students have participated in Google Code-In (2014) again and for many of them it has been the first opportunity to make contributions to Free Software and Open Source projects. In opposite to Google Summer of Code the GCI program is organized as a worldwide contest where students at the age of 13-17 years take the challenge to complete as many software development tasks from their mentor organizations as possible.


Folder View panel popups are list views again

In later versions of Plasma 4, the Folder View widget adopted a special appearance when placed in a panel: It would arrange folder contents in a simple list instead of the usual icon grid. Folder View had to be rewritten completely for Plasma 5, and while there were various improvements along the way, the list view mode unfortunately went missing. Until now - on popular request, this feature will make a return soon in Plasma 5.4:


Updates on Kate's Rust plugin, syntax highlighting and the Rust source MIME type

The other day I introduced a new Rust code completion plugin for Kate, powered by Phil Dawes' nifty Racer. Since then there's been a whole bunch of additional developments!

New location

Originally in a scratch repo of mine, the plugin has now moved into the Kate repository. That means the next Kate release will come with a Rust code completion plugin out of the box! (Though you'll still need to grab Racer yourself, at least until it finds its way into distributions.)

For now the plugin still works fine with the stable release of Kate, so if you don't want to build all of Kate from git, it's enough to run make install in addons/rustcompletion in your Kate build directory.

This also means the plugin is now on bugs.kde.org - product kate, component plugin-rustcompletion (handy pre-filled form link). And you can submit patches via ReviewBoard now.

New feature: Go to Definition

In addition to code completion popups, the plugin now also installs Go to Definition action (in the Edit menu, the context menu, and you can configure a keyboard shortcut for it as well). It will open the document containing the definition if needed, activate its view and place the cursor at the start of the definition.

Rust syntax highlighting now bundled with Frameworks

After brainstorming with upstream, we decided together that it's best for Rust and Kate users to deprecate the old rust-lang/kate-config repository and move the syntax highlighting file into KDE's KTextEditor library (the foundation of Kate, KDevelop and several other apps) for good, where it now resides among the many other rules files. With 1.0 out the door, Rust is now stable enough that delivering the highlighting rules via distro packages becomes feasible and compelling, and moving the development location avoids having to sync multiple copies of the file.

The full contribution history of the original repo has been replayed into ktexteditor.git, preserving the record of the Rust community's work. The license remains unchanged (MIT), and external contributions remain easy via ReviewBoard or bugs.kde.org.

KTextEditor is a part of KDE's Frameworks library set. The Frameworks do monthly maintenance releases, so keeping up with the Rust release cadence will be easy, should the rules need to be amended.

It's a MIME type: text/rust

Kate plugins and syntax highlighting files preferably establish document identity by MIME type, as do many other Linux desktop applications. The desktop community therefore maintains a common database in the shared-mine-info project. With the inclusion of a patch of mine on May 18th, shared-mime-info now recognizes the text/rust type for files matching a *.rs glob pattern.

If you're searching, opening or serving Rust source files, you should be using text/rust from now on.

That's it for today! I still have a bunch of improvements to the plugin planned, so stay tuned for future updates.


Basic code completion for Rust in KDE's Kate (and later KDevelop)

A few days ago the Rust community announced v1.0 of their new systems programming language, Rust. Having followed the project for some time and finally having used the language for a number of small projects this year, I've come to feel that using Rust is interesting, fun and productive. I'd like to highly encourage everyone to give it a look now that it's finally considered ready for prime time.

To aid the effort I've put some Sunday hacking time into a basic Rust code completion plugin for Kate today. It's built around Phil Dawes' very nifty Racer, freeing it up to concern itself only with exposing some configuration and getting data provided by Racer into Kate. Not difficult at all.

This is what it looks like in action:

The Rust code completion plugin for Kate


The plugin is very basic at the time of writing (which is minutes after getting things working, this Sunday is running out!). The mapping of completion match metadata to Kate's format (from fundamentals like the match type, to more complex features like smart grouping) can likely be improved still. Ditto for auto-completion behavior (i.e. defining the circumstances in which the completion popup will kick in automatically, as opposed to waiting for manual invocation) and simply performance.

The plugin also doesn't work in KDevelop 5 yet, although that one's on KDevelop -- it doesn't support the KTextEditor plugin type present in Frameworks 5 yet. I'm told the KDevelop team has addressing this on their agenda.

Syntax highlighting

Both KDE and Rust implement the AwesomeCommunity trait. The Rust community in particular maintains an official Kate syntax highlighting file here. The repository for the Kate plugin includes this as a submodule and installs it by default; if you'd like it not to do that, there's a build system toggle to disable it. Update: With the move of the plugin source (see below), this is currently no longer the case, but the upstream repo now has install instructions!

A MIME type for Rust source code

While the plugin will run for all *.rs files, Kate/KDevelop plugins and syntax highlighting files preferably identify documents by their MIME type. It turns out there isn't a MIME type for Rust source code in shared-mime-info yet, so I've started the process of getting one in. (Update: Merged, along with this and this!)

Getting the plugin

The plugin is currently still hosted in a personal scratch repo of mine, on git.kde.org. You can browse the source , or skip straight to this clone URL:


This location might change if/when the plugin is promoted to proper project status; I'll update the post should that happen. I've included some install instructions that go over requirements, options and configuration. Note that you need a Rust source tree to get this working. Check them out!

Update: As of May 20th 2015, the plugin is now bundled with Kate in its repository (browse), to be included in the next Kate release. You can get it by building Kate from git as whole, or you can do make install in just the plugin's subdir of your build dir; at this time it works fine with Kate's last stable release. Given all this, I'll only quickly recap some additional info for getting it working here: Once you've enabled the Rust code completion item in the plugin page, a new page will appear in your Kate config dialog. Within are config knobs for the command to run Racer (which you'll therefore need an install of) and the path to a Rust source tree (which you can of course grab here), which Racer needs to do its job. Make sure both are set correctly, and then start editing!

Getting in touch

If you have any comments or requests and the blog won't do (say, you have a cool patch for me), you can find my mail address inside the AUTHORS file included in the repository. Signing up for KDE.org's proper bug tracking and patch submission pathways is still pending :-). Update: After the move to Kate's repository (see above), you can now file bugs and wishes against the plugin via the plugin-rustcompletion component of the kate product on our bugtracker (handy pre-filled form link). You can also submit patches via ReviewBoard now.