CMake 3.12 has reached rc1. That means we’re testing the update on FreeBSD, and building lots and lots of packages. And, as I’ve written previously, every CMake update triggers a bunch of interesting software findings.

As a motto, I’ve got “use it, aggressively improve it” on my website (you can hire me for odd CMake and C++ jobs, too). So hitting compile issues makes me turn to fixing software outside of KDE.

• Spring is a 3D RTS engine, with only a minor CMakeLists fix — CMake 3.12 is strict about file(GLOB) and the FOLLOW_SYMLINKS keyword, which is documented only for file(GLOB_RECURSE). Since CMake 3.5, probably much earlier, that keyword has been ignored, and now it’s an error (this is considered a regression).
• Coin3D is a 3D toolkit, which in the version currently available on FreeBSD, doesn’t even use CMake. It hit a bunch of Clang6 compatibility issues, and after some investigation it turns out they had all been fixed already in later releases; I put in a little time to improve FreeBSD compatibility for the next release.

What I found interesting in those two was once again the variety in CMake styles — “Modern CMake Style” still needs to catch on in many places, and the wider ecosystem. Mantis bug-tracker! Mercurial! I remember being a big Mercurial fan years ago when doing KDE-Solaris and complaining how obtuse git is. (It’s still obtuse, but I’m used to it now).

There’s another four dozen ports that have fallout from this update; amusingly Kitware’s VTK 5 and VTK 6 are among them — although a first glance tells me that’s C++ problems and not CMake problems, actually. (Generally, using NULL in places where you want to write 0; older macro definitions of NULL would re-write to something that could successfully be cast to 0, but clang6 in C++17 mode, the default, uses nullptr which doesn’t cast).

At my company we use C++ for everything, from creating microservices to website backends and as a generator for website frontends, I mean, we do a lot of c++. And because of that we always need more c++ people, but sometimes it’s hard to find developers, but it’s easy to find php / python / javascript ones. Because of that we hired Kate Gregory’s famous c++ course – “Teaching the Teacher” to train current C++ developers to teach C++. (now, that’s a lot of ‘C++’ in a simple sentence, I know. bear with me.)

For those that doens’t know, Kate Gregory is somebody that uses, advocates our beloved language even before I was born, and talks all over the world about C++ and also do trainings for companies, And so I enlisted to be her student.

It was a really pleasant course going thru how to proplery explain C++ for people that know how to program but don’t know how to C++, and for that I’m grateful. But then when I commented out about Qt in the middle of the class she rolled her eyes, that made me feel a bit uneasy so I talked to her on why the eye-roll. “Qt is not c++”, and I tougth this was already settled down for years, so I asked her if she would be open to see some simple c++ code written in Qt and tell me what she thinks of it. “Well, Yes. but people already tried and it was not good”.

Then I tried, and when you are showing Qt to people that are interested in the language there’s a few things that you should not try to talk about:

• Don’t talk about Qt Creator, it’s common that they have a favorite editor, and Qt is unrelated to Qt Creator
• Don’t talk about Designer, drag’n drop is not a feature for algorithm-minded people.
• Don’t talk about QtWidgets, it’s a nice feature to have and everybody knows that Qt has it, talk about something else.
• Don’t talk about qmake, tha’s irrelevant, every IDE has a way of building software, and if they don’t use a IDE they know how to use a Makefile or similar.

What I actually talked about, to remove some misconceptions about “Qt is for Widgets, Qt is Not C++”

• moc is uneeded, you can create complete Qt applications without it.
  • you don’t need to use moc-like code if you don’t inherit from QObject
  • if you inherit you need to use moc-like code, but that can be done with:
    • moc, easiest way.
    • hand written if you feel like it (but why?)
    • use Verdigris a header library that generates moc-style code.
• Create something that’s unrelated to a Widget, use QNetwork, Threads or somerthing.

I’v created the following source codes, all compile without moc, all are clean c++ code for people that don’t belive Qt can be compiled with a plain compiler, all of them are *way* easier to read and write than anything that the STL can provide, and I’v showed them to Kate. (wordpress don’t let me update cpp files so I renamed it to txt)

• resize_pictures Resize all pictures in the home folder
• debug_outputs Debug output with line information
• dump_json_timely Dump a json object into a file, read the file line-by-line each quarter of second
• download_flamingo_and_display Download a Flamingo from the internet and display it.

After looking at them Kate said “You are actually the first person to show me Qt code that’s nice to look, this is actually pleasant.”, I realized that whenever We (and by we I mean KDE, Qt Company, Qt Advocates) try to advocate Qt to C++ developers we attack in the wrong front, let’s put less focus on Widgets / QML and more focus on easy of use for things that STL provides and Qt does better, or for things that STL *should* provide but doesn’t (like QString vs std::string – it’s 2018 and till today there’s no codepoint support for utf-8 in it, sigh).

Times pass and we all change. I’ve realized that I’ve gone from mostly coding at work, to almost not coding at all (I reflect on this in the Under utveckling pod – Swedish only). I’ve also realized that what I do in automotive has a much wider application (see my fosdem talk on this). Thus, the conclusion is that the time has come to change context.

I’ve also spent a lot of time on promoting free and open source software. I’ve spoken at conferences, gone to hackathlons, spoken at the university, and arranged meetups. All this culminated in foss-north which I’ve been organizing for the past three years.

The conclusion from all of this is that there is an opportunity to focus on this full time. How can free and open source software be leveraged in various industries? How does one actually work with this? How does licensing work? and so on. To do so, I founded my own company – koderize – a while back and from now on I’m focusing fully on it.

Before joining Pelagicore back in 2010 I was solo consulting for a year. This was a great opportunity and I finally got to spend some time working directly with the former Trolls at what later became The Qt Company. However, I also came to realize that solo consulting makes me go slightly mad. Also, my wife complained that I talked to much every afternoon when she came home ;-)

Thus, I want colleagues. That is why myself and some great people that I’ve passed by during my years in this field are founding Kuro Studio (the web page is minimalist – i.e. empty).

The team we’re setting up complement each other and the sum of our experience covers the full full-stack. We can do team building, purchasing, processes, QA, agile, development, design, licensing, devops – even some hardware. The goal is to create an end-to-end product design team that can help out during any phase of product development, as well as organizational development.

At the end of the day I’m still passionate about what I have been doing the past 8 years. Cars excite me, and combining that with Qt and Linux makes me even more excited. That means that I’ll still be around in that field. As a matter of fact, my first assignment is in that area.

So, at the end of the day, time pass, we grow, but some things still stay the same. A big thank you to everyone at Pelagicore – it was a great ride.

About two weeks ago i attended Qt Contributor Summit 2018, i did so wearing my KDAB hat, but given that KDE software is based heavily on Qt I think I'll give a quick summary of the most important topic that was handled at the Summit: Qt 6

• Qt 6 is planned for a November 2020 release
• Qt 5 releases will continue with the current cadence as of now with 5.15 being the last release (and also LTS)
• The work branch for Qt 6 will be branched soon after Qt 5.12
• Qt 6 has to be easy to migrate from Qt 5
• Qt 6 will use C++17
• Everything to be removed in Qt 6 should be marked as deprecated in 5.15 (ideally sooner)
• What can be done in Qt 5 should be done to Qt 5
• Qt 6 should be a "boring" release user feature wise, mostly cleanup and preparing for the future
• Qt 6 should change things that break at compile time, those are easy to fix, silent runtime changes are scarier
• Qt 6 will not use qmake as build system
• The build system for Qt 6 is still not decided, but there's people working on a qbs build and noone working on any other alternative

0.2 Beta Release of Elisa Music Player

Elisa is a music player developed by the KDE community that strives to be simple and nice to use. We also recognize that we need a flexible product to account for the different workflows and use-cases of our users.

We focus on a very good integration with the Plasma desktop of the KDE community without compromising the support for other platforms (other Linux desktop environments, Windows and Android).

We are creating a reliable product that is a joy to use and respects our users privacy. As such, we will prefer to support online services where users are in control of their data.

New Features and Improvements

The main area of improvements are the following:

• We have been fixing problems related to music import (different albums being merged, …) and general handling of music metadata ;
• Improve cover images discovery (should fix most common cases) ;
• Improve performance of the internal music database ;
• Improve build time by factoring most c++ code in a dedicated library ;
• Improvement of the player control bar with most controls related to playback being located here ;
• Only load a music browsing view when it is used (faster and lighter on memory usage) ;
• Add a browsing view by genres ;
• Add a browsing view for the filesystem.

Current Elisa Interface

Test of the future 0.2 version

The release is available from elisa-0.1.80.tar.xz and also in the form of a Windows setup (generated using Craft and binary-factory.kde.org). You can also test by using the nightly flatpak builds from KDE.

Please report any issues to the KDE bugtracker.

Of course I am using KDE software much longer. My first Linux distribution, SuSE 6.2 (the precursor to openSUSE), came with KDE 1.1.1 and was already released 19 years ago. But this post is not celebrating the years I am using KDE software.

Exactly ten years ago, dear Albert committed my first contribution to KDE. A simple patch for a problem that looked obvious to fix, but waiting for someone to actually do the work. Not really understanding the consequences, it marks the start of my journey within the amazing KDE community.

Bug Triaging and Quality

In the following ten years, I contributed to or resolved thousands of bugs in kdelibs, systemsettings, and various other KDE software. Much of the passion to triage and tackle bugs do I owe Darío Andrés, the original author of our bug triaging guide. I have not heard from him later, but hope he does well.

Long before we had a continuous build service, I used to build nearly all KDE software with a self-written script, monitoring its output for build errors and newly introduced compiler warnings. Someone surely remembers my constant mails about failing builds and other issues I felt responsible for as part of the quality assurance in the KDE team.

Theming and Decorations

Besides tackling wierd crashes, I was also active in UI polishing, freeing our code from hard-coded spacings, colors, font or icon sizes, using my own Qt widget style Skulpture and a specially crafted color scheme as a testbed. Not that dark themes and HiDPI displays were common ten years ago; I just always liked the full control of the user over his software. After all, UI stands for User Interface.

The Skulpture style came with its own simple KWin window decoration. For those not satisfied with its look, I ported and improved the Dekorator theming engine, and even created a version of Emerald (the Compiz/Beryl decorator) for KDE4, called Smaragd, which has recently been ported to Plasma 5. Once installed, it gives Plasma 5 users access to over thousand window decoration themes.

Applications Porting and Releasing

Apropos porting: Hopefully my porting status page was useful for contributors to decide where to help, and for users to decide when to switch. Besides tracking porting progress, I helped porting small utilities, such as KCalc, KCharSelect, KCron, KMag, and KRuler, but also bigger applications, such as KmPlot, KolourPaint, and KTurtle. You might notice a slight bias towards math and graphics applications

The longer you are part of a community, the more responsibilites you are going to accept. Being the maintainer of a few KF5 frameworks is not exactly exciting. But a year ago, I got the opportunity to help Albert with KDE Applications releases, learning about the release process, including tagging, packaging tarballs, and posting announcements. Creating a release is a nice way to see all the fruits of the work of many contributors coming together.

So what am I going to do in the next ten years? If you had asked me that question ten years ago, I could not have given you an answer, and I am glad I cannot give you answer today. What is so special about the KDE community is that it constantly gives you new problems to tackle, and I hope I will be able to report in ten years which of them we mastered.

After my last post I downloaded clang, compiled clazy and got in contact with Sergio Martins – the main Clazy developer asking for some tips on how to start, as everyone should know LLVM is a compiler infrastructure that’s changing the world with quite a few projects, like Emscripten, Cling LLDB and the most well known tool: Clang

Every c++ developer of today’s world should praise Clang as it’s library and server mode are being used in Qt Creator, CLion and others for correctly parsing C++ code. I have *never* touched this kind of code, and I’m fearfull for my life. But knowing that Appending to temporaries is a worse solution than creating a static std::initializer_list gives me no other option, also, I’m bored.

Following Sergio’s advice I dumped the AST of the offending code and the AST of the good code:

clang++ -fsyntax-only -Xclang -ast-dump -fno-color-diagnostics qt_test_good.cpp > good.tree
clang++ -fsyntax-only -Xclang -ast-dump -fno-color-diagnostics qt_test_bad.cpp > bad.tree

The codes this time are a bit different than the ones I’v showed all yesterday as I’m only interested in The offending line, so I removed all for loops and all possible distraction that I had.

// bad code
int main() {
    QVector<int>() << 1 << 2 << 3 << 4 << 5;
}

// good code
int main() {
    QVector<int> {1, 2, 3, 4, 5};
}

And started to analyze the AST – For those who are not techically savy, AST stands for Abstract Syntax Tree and it describes what the program should do. and the good code, the small, one liner, good code dumped an AST of about 70.000 lines. *OH NOES!* I screamed, it’s impossible to actually understand that, that’s soo much stuff going on that I don’t even know where to start.

Then I looked at the function main and managed to strip out around 69.950 lines of code, Now this is actually userfull:

`-CompoundStmt 0x55dec0933910 <col:12, line:6:1> |-ExprWithCleanups 0x55dec09338c0 <line:4:5, col:47> 'QVector':'QVector'
| `-CXXBindTemporaryExpr 0x55dec09338a0 <col:5, col:47> 'QVector':'QVector' (CXXTemporary 0x55dec0933898)
| `-CXXTemporaryObjectExpr 0x55dec0933858 <col:5, col:47> 'QVector':'QVector' 'void (std::initializer_list)' list std::initializer_list
| `-CXXStdInitializerListExpr 0x55dec0933750 <col:17, col:47> 'std::initializer_list':'std::initializer_list'
| `-MaterializeTemporaryExpr 0x55dec0933738 <col:17, col:47> 'const int [10]' xvalue
| `-InitListExpr 0x55dec09336a8 <col:17, col:47> 'const int [10]'
| |-IntegerLiteral 0x55dec09239a8  'int' 1
| |-IntegerLiteral 0x55dec09239c8  'int' 2
| |-IntegerLiteral 0x55dec09239e8  'int' 3
| |-IntegerLiteral 0x55dec0923a08  'int' 4
| |-IntegerLiteral 0x55dec0923a28  'int' 5
`-ReturnStmt 0x55dec09338f8 <line:5:5, /usr/include/stdlib.h:92:22> `-IntegerLiteral 0x55dec09338d8  'int' 0

This is Tiny, and somewhat simple to understand what’s going on. I have no idea about the CompoundStmt, CXXTemporaryObjectExpr, InitListExpr and so on but I don’t care about that now, I’m only interested in trying to figure out the tree.

And here the Bad code: see something strange?

`-FunctionDecl 0x55c00766a5f8 <main.cpp:3:1, line:6:1> line:3:5 main 'int ()'
`-CompoundStmt 0x55c00767a098 <col:12, line:6:1>
|-ExprWithCleanups 0x55c00767a048 <line:4:5, col:68> 'QVector<int>':'QVector<int>' lvalue
| `-CXXOperatorCallExpr 0x55c00767a000 <col:5, col:68> 'QVector<int>':'QVector<int>' lvalue
| |-ImplicitCastExpr 0x55c007679fe8 <col:65> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | `-DeclRefExpr 0x55c007679fc0 <col:65> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| |-CXXOperatorCallExpr 0x55c007679f40 <col:5, col:63> 'QVector<int>':'QVector<int>' lvalue
| | |-ImplicitCastExpr 0x55c007679f28 <col:60> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | `-DeclRefExpr 0x55c007679f00 <col:60> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | |-CXXOperatorCallExpr 0x55c007679e80 <col:5, col:58> 'QVector<int>':'QVector<int>' lvalue
| | | |-ImplicitCastExpr 0x55c007679e68 <col:55> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | `-DeclRefExpr 0x55c007679e40 <col:55> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | |-CXXOperatorCallExpr 0x55c007679dc0 <col:5, col:53> 'QVector<int>':'QVector<int>' lvalue
| | | | |-ImplicitCastExpr 0x55c007679da8 <col:50> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | | `-DeclRefExpr 0x55c007679d80 <col:50> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | | |-CXXOperatorCallExpr 0x55c007679d00 <col:5, col:48> 'QVector<int>':'QVector<int>' lvalue
| | | | | |-ImplicitCastExpr 0x55c007679ce8 <col:45> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | | | `-DeclRefExpr 0x55c007679cc0 <col:45> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | | | |-CXXOperatorCallExpr 0x55c007679c40 <col:5, col:43> 'QVector<int>':'QVector<int>' lvalue
| | | | | | |-ImplicitCastExpr 0x55c007679c28 <col:40> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | | | | `-DeclRefExpr 0x55c007679c00 <col:40> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | | | | |-CXXOperatorCallExpr 0x55c007679b80 <col:5, col:38> 'QVector<int>':'QVector<int>' lvalue
| | | | | | | |-ImplicitCastExpr 0x55c007679b68 <col:35> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | | | | | `-DeclRefExpr 0x55c007679b40 <col:35> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | | | | | |-CXXOperatorCallExpr 0x55c007679ac0 <col:5, col:33> 'QVector<int>':'QVector<int>' lvalue
| | | | | | | | |-ImplicitCastExpr 0x55c007679aa8 <col:30> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | | | | | | `-DeclRefExpr 0x55c007679a80 <col:30> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | | | | | | |-CXXOperatorCallExpr 0x55c007679a00 <col:5, col:28> 'QVector<int>':'QVector<int>' lvalue
| | | | | | | | | |-ImplicitCastExpr 0x55c0076799e8 <col:25> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | | | | | | | `-DeclRefExpr 0x55c0076799c0 <col:25> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | | | | | | | |-CXXOperatorCallExpr 0x55c007679940 <col:5, col:23> 'QVector<int>':'QVector<int>' lvalue
| | | | | | | | | | |-ImplicitCastExpr 0x55c007679928 <col:20> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | | | | | | | | | | `-DeclRefExpr 0x55c0076798a8 <col:20> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'
| | | | | | | | | | |-CXXBindTemporaryExpr 0x55c007679828 <col:5, col:18> 'QVector<int>':'QVector<int>' (CXXTemporary 0x55c007679820)
| | | | | | | | | | | `-CXXTemporaryObjectExpr 0x55c0076797e8 <col:5, col:18> 'QVector<int>':'QVector<int>' 'void () noexcept'
| | | | | | | | | | `-MaterializeTemporaryExpr 0x55c007679868 <col:23> 'int':'int' xvalue
| | | | | | | | | | `-IntegerLiteral 0x55c007679848 <col:23> 'int' 1
| | | | | | | | | `-MaterializeTemporaryExpr 0x55c0076799a8 <col:28> 'int':'int' xvalue
| | | | | | | | | `-IntegerLiteral 0x55c007679988 <col:28> 'int' 2
| | | | | | | | `-MaterializeTemporaryExpr 0x55c007679a68 <col:33> 'int':'int' xvalue
| | | | | | | | `-IntegerLiteral 0x55c007679a48 <col:33> 'int' 3
| | | | | | | `-MaterializeTemporaryExpr 0x55c007679b28 <col:38> 'int':'int' xvalue
| | | | | | | `-IntegerLiteral 0x55c007679b08 <col:38> 'int' 4
| | | | | | `-MaterializeTemporaryExpr 0x55c007679be8 <col:43> 'int':'int' xvalue
| | | | | | `-IntegerLiteral 0x55c007679bc8 <col:43> 'int' 5
| | | | | `-MaterializeTemporaryExpr 0x55c007679ca8 <col:48> 'int':'int' xvalue
| | | | | `-IntegerLiteral 0x55c007679c88 <col:48> 'int' 6
| | | | `-MaterializeTemporaryExpr 0x55c007679d68 <col:53> 'int':'int' xvalue
| | | | `-IntegerLiteral 0x55c007679d48 <col:53> 'int' 7
| | | `-MaterializeTemporaryExpr 0x55c007679e28 <col:58> 'int':'int' xvalue
| | | `-IntegerLiteral 0x55c007679e08 <col:58> 'int' 8
| | `-MaterializeTemporaryExpr 0x55c007679ee8 <col:63> 'int':'int' xvalue
| | `-IntegerLiteral 0x55c007679ec8 <col:63> 'int' 9
| `-MaterializeTemporaryExpr 0x55c007679fa8 <col:68> 'int':'int' xvalue
| `-IntegerLiteral 0x55c007679f88 <col:68> 'int' 10
`-ReturnStmt 0x55c00767a080 <line:5:5, /usr/include/stdlib.h:92:22>
`-IntegerLiteral 0x55c00767a060 <col:22> 'int' 0
g++ -Wl,-O1 -Wl,-O1,--sort-common,--as-needed,-z,relro,-z,now -o testeQt main.o -lQt5Gui -lQt5Core -lGL -lpthread

I mean, I’m no genious but I can clearly see the difference (that’s different than understand, I’m still trying that second part.)

but I can see that those lines

| `-CXXOperatorCallExpr 0x55c00767a000 <col:5, col:68> 'QVector<int>':'QVector<int>' lvalue
| |-ImplicitCastExpr 0x55c007679fe8 <col:65> 'QVector<int> &(*)(int &&)' <FunctionToPointerDecay>
| | `-DeclRefExpr 0x55c007679fc0 <col:65> 'QVector<int> &(int &&)' lvalue CXXMethod 0x55c007677858 'operator<<' 'QVector<int> &(int &&)'

repeat for each number that I append into the vector untill I find a

-CXXBindTemporaryExpr 0x55c007679828 <col:5, col:18> ‘QVector<int>’:’QVector<int>’ (CXXTemporary 0x55c007679820)

Hours reading the documentation, talking to Sergio, crying and hacking into clazy I have a (somewhat buggy and experimental) check that will warn you if you are appending to a temporary using operator-shift-left. I plan to send this to review this week and as soon as it’s 100% I’ll run in the entire KDE codebase.

Hi!

The first evaluation was done and I successfully passed!

I got some problems during the last weeks of Google Summer of Code which made me deal with some challenges. One of these challenges was caused by a HD physical problem. I haven’t made a backup of some work and had to rework again in some parts of my code. As I already knew how to proceed, it was faster than the first time.

I had to understand how the device loading process is made in Calamares to load a preview of the new LVM VG during its creation in Partition Page. I need to list it as a new storage device in this page and deal with the revert process. I’ve implemented some basic fixes and tried to improve it.

There were some problems when reverting pending operations, especially when you got an old LVM VG configured in your system. This problem was related to kpmcore scanDevice procedure. SfdiskBackend::scanDevice method is responsible to load a device based on its partition node, but it only was considering disk devices and ignoring logical devices.

LVM VGs were only loaded using SfdiskBackend::scanDevices method, which loads all the devices found in your system. Calamares uses scanDevice during revert process, to update the devices references according with the original ones. So, when some old VG was previously configured, the revert process tries to call scanDevice and was getting only a nullptr reference, causing an unexpected segfault.

I fixed this method to load the specified VG, but my solution needs to know all the physical devices contained in your system to do it, as you can see in this commit:

https://cgit.kde.org/kpmcore.git/commit/?id=358957641b2c7ff6b69d090c9e1fddba482c6817

As you can imagine, it can take a significant time of processing in some cases, because it will load all the devices every time when you need to load a specific VG. I need to improve it, using some other procedure, but I’m worried about the loading of LVM PVs, that will require to load each device which the PV is associated.

About my progress in Calamares during this time, you can take a look in some commits in my PR:

https://github.com/calamares/calamares/pull/984

Well, it’s being a great experience, but I need to improve some things in my work and in its processes, especially with the communication, I’m learning about how to be a more communicative person in open source projects. I’m getting a great knowledge!

I’m a speed freak. I don’t belive that “early optimization is the root of all evil”, if we do not optmize our software we may as well run everything in debug mode as it’s much easier for a developer to understand what’s going on. But we live in the real world and things should be snappy, and fast.

I’m really annoyed to find *some* stuff that I always tougth it’s slow but I never had the desire to actually measure it, now I did. I runned the code six times to have sane results., all code is configured to compile with g++ and  -02

First code:

int main() {
         long count = 0;
         for (int i = 0; i < 100000000; i++) {
                auto list = QList<int>{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
                count += list.size();
         }
         return EXIT_SUCCESS;
}

testeQt|: time ./testeQt
./testeQt 6.15s user 0.01s system 99% cpu 6.169 total
testeQt|: time ./testeQt
./testeQt 6.22s user 0.01s system 99% cpu 6.235 total
testeQt|: time ./testeQt
./testeQt 8.19s user 0.03s system 96% cpu 8.487 total

Second Code:

int main() {
         long count = 0;
         for (int i = 0; i < 100000000; i++) {
                auto list = QList<int>() << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10;
                count += list.size();
         }
         return EXIT_SUCCESS;
}

Second Code:

testeQt|: time ./testeQt 
./testeQt 13.94s user 0.01s system 98% cpu 14.106 total
testeQt|: time ./testeQt
./testeQt 15.38s user 0.02s system 98% cpu 15.591 total
testeQt|: time ./testeQt
./testeQt 14.27s user 0.01s system 99% cpu 14.328 total

Bottom Line: Stop using QVector / QList () with operator << for a fixed amount of items. It’s painfully slow compared to a initializer_list.

I’ve learned that IBM Travelstar 40GB drives use glass platters. I learned this the fun way, by bending one in a vice, with a big set of pliers. It went snap, tinkle — a different sound from other drives. And after that the bendy drive was usable as a maraca!

So why was I bending drives in the first place?

Well, I volunteer some of my time at a local second-hand place called Stichting Overal. It is an “idealistic” organisation that uses the revenue from second-hand sales to support various projects (generally small-scale development, like funding the construction of sanitation in schools). Like most second-hand stores, there’s clothes and ancient kitchen appliances and books and used bicycles .. and also an IT corner.

I help out Tom, a local school kid who has run the IT corner for some time. From time to time a PC or monitors or random IT crap is dropped off for re-use, and we apply triage. Yes, that is a lovely 486DX2, but it is still going into the bin. For various reasons, there’s a mismatch between supply and demand of hard drives: we end up with piles of small ATA-33 drives, and very few 80GB-or-more SATA drives.

Machines that show up and not immediately consigned to the bin are thoroughly cleaned (’cause, eww). Some machines are cannibalized for parts for others. Working, usable hard drives are wiped, and then re-triaged. Since we don’t want to leak whatever data is on the drives (even after wiping, and customers aren’t always all that careful about what they bring in either), leftover drives are destroyed.

So that’s why I was contorting a laptop drive. Here’s a Christmas ornament I have made out of a desktop 3.5″ drive.

Machines that get through this gauntlet are dd’ed with zeroes, then installed with some flavor of GNU/Linux. Even if there’s a valid Windows license attached to the machine, getting that installed correctly and legally is way more effort for us than doing something we know is right (and Free). Lately it’s been Fedora 27 with rpmfusion, and a KDE Plasma 5 desktop (I didn’t do the choosing, so this was a pleasant surprise). Frankly, I’m not convinced we’re doing a really good job in delivering the Linux desktop PC experience to the buyers, since there’s no Linux / Fedora documentation included (now I write that down, I realise we should probably check if there’s licensing obligations we need to follow up on). What it kinda needs is an OEM installer to do some post-sale configuration like setting up a user (I can think of at least one).

I work for atelier together with Chris, Lays and Patrick for quite a while, but I was basically being the “guardian angel” of the project being invocked when anything happened or when they did not know how to proceed (are you a guardian angel of a project? we have many that need that)

For instance I’v done the skeleton for the plugin system, the buildsystem and some of the modules in the interface, but nothing major as I really lacked the time and also lacked a printer.

Now I got my first 3d printer, and for the first time in two years I can actually test the program that I’m helping to build for so long, and peeps, I can confirm that we have a working 3d printer host in KDE, and it’s really good.

It has some quircks, obviously, but it’s really good.

Perhaps if Windows wasn’t such a PITA there would be more progress

• The Conversation view received some vim-style keyboard bindings (because who uses a mouse anyways).
• The INBOX is now automatically selected when Kube is started, so we show something useful immediately.
• Progress on Kube for Windows. Everything builds, but there are still a couple of remaining issues to sort out.
• Ported from QGpgME to plain old GpgME. This was a necessary measure to build Kube on Windows, but also generally reduced complexity while removing the dependency on two large libraries that do nothing but wrapping the C interface.
• Ported away from readline to cpp-linenoise, which is a much simpler and much more portable replacement for readline.
• Rémi implemented the first steps for range queries, which will allow us to retrieve only the events that we require for to e.g. render a week in the calendar.
• The storage layer got another round of fixes, fixing a race condition that could happen when initially creating the database for the first time (Blogpost on how to use LMDB).
• The IMAP resource no longer repeatedly tries to upload messages that don’t conform to the protocol (Not that we should ever end up in that situation, but bugs…).
• The CalDAV/CardDAV backends are now fully functional and support change-replay to the server (Rémi).
• The CalDAV backend gained support for tasks.
• Icons are now shipped and loaded from a resource file after running into too many problems otherwise on Windows.
• A ton of other fixes for windows compatiblity.
• A bunch of mail rendering fixes (also related to autocrypt among others).
• Work on date range queries for efficient retrieval of events has been started.

Kube Commits, Sink Commits

Previous updates

More information on the Kolab Now blog!

“Kube is a modern communication and collaboration client built with QtQuick on top of a high performance, low resource usage core. It provides online and offline access to all your mail, contacts, calendars, notes, todo’s and more. With a strong focus on usability, the team works with designers and UX experts from the ground up, to build a product that is not only visually appealing but also a joy to use.”

For more info, head over to: kube.kde.org

The last 2 weeks were mainly dedicatd for reviews and testing and thanks to my mentors, I passed the first evaluation with good work till now. Some significant changes were made on discussion with my mentors during the last 2 weeks in the code and some new features. Added E3, F3, D6, E6, F6 keys …

Continue reading "GSoC 2018: Week 4 & 5"

I started to hack in Konsole, and first I was afraid, I was petrified. You know, touching those hardcore apps that are the center of the KDE Software Collection.

I started touching it mostly because some easy to fix bugs weren’t fixed, and as every cool user knows, this is free software. So I could pay for someone to fix my bugs,  or I could download the source code and try to figure out what the hell was wrong with it. I choosed the second approach.

If you have something for me to improve in konsole please poke-me, as I have landed around 25 commits this past week and I plan to continue that.

I would also like to thank my employer for letting me stay late hacking in KDE related software.

I am happy to announce the release of Kraft version 0.81. Kraft is a Qt based desktop application that helps you to handle documents like quotes and invoices in your small business.

Version 0.81 is a bugfix release for the previous version 0.80, which was the first stable release based on Qt5 and KDE Frameworks5. Even though it came with way more new features than just the port, it’s first release has proven it’s stability in day-to-day business now for a few month.

Kraft 0.81 mainly fixes building with Qt 5.11, and a few other installation- and AppStream metadata glitches. The only user visible fix is that documents do not show the block about individual taxes on the PDF documents any more if the document only uses one tax rate.

Thanks for your suggestions and opinions that you might have about Kraft!

Howdy folks! This has been a bit of a light week for KDE’s Usability and Productivity initiative, probably because everyone’s basking in the warm glow of a well-received release: KDE Plasma 5.13 came out on Tuesday and is getting great reviews!

Don’t worry, we’ve got lots of great stuff queued up though.

Bugfixes

• The context menu for desktop icons now correctly toggles between Move to Trash and Delete when the Shift key is pressed (Eike Hein, KDE Plasma 5.12.6)
• Any toolbar buttons in Kate and KWrite (and other apps using the KTextEditor frameworks) that display a drop-down menu when you click on them now display the menu properly when you click on them normally, instead of requiring a click-and-hold (me: Nate Graham, KDE Frameworks 5.48)

UI Polish & Improvement

• The Libinput-backend Mouse and Touchpad System Settings pages received a visual and usability overhaul (Furkan Tokac, KDE Plasma 5.14):
  
  
• Discover’s Updates page is now clearer about what version is being upgraded (me: Nate Graham, KDE Plasma 5.14):
  
• Scrollbars in Konsole are now overlay style and disappear entirely when the view isn’t scrollable, e.g. with a full-screen CLI program like top (Tomaz Canabrava and Alex Nemeth, KDE Applications 18.08.0)

See all the names of people who worked hard to make the computing world a better place? That could be you next week! Getting involved isn’t all that tough, and there’s lots of support available. Give it a try today! It’s easy and fun and important.

If my efforts to perform, guide, and document this work seem useful and you’d like to see more of them, then consider becoming a patron on Patreon, LiberaPay, or PayPal.

The week was totally involved in developing the GUI for QML Plugins. The follwoing APIs are developed:

• BrowserAction API: to add a GUI popup button to navigation tool bar and status bar
• SideBar API: to add a side bar widget to the browser

Below are the screeshots of the Hello QML plugin from the my working branch

BrowserAction Button

Browser Action Button can be added to either Navigation Tool Bar or Status Bar or both.

BrowserAction Popup

The popup for Browser Action Button is in form of QML Window. This part took much time to develop because:

• To show the GUI, QQuickWidget (QWidget) or QQucikWindow (QWindow) can be used.
• Now popup property is a QQmlComponent thus the source Url is not known. Also QQuickWidget uses url - thus only solution left is to use QQuickWindow (by casting object created using QQmlComponent::create)
• Now to show popup the Qt::Popup flag is needed for QQuickWindow.

Everything is fine upto this until I found that this didn't worked. My Mentor (David Rosca) explained that this is because the QWindow is not grabing mouse and keyboard events - which means that the window is not activated - so I added QWindow::requestActivate and It works like a charm!

SideBar Menu

SideBar

Again SideBar menu is a QQuickWindow which is embeded into the browser using QWidget::createWindowContainer.

Happy Fathers Day!

As you might have heard I decided to step down from my maintainer positions in KDE, especially KWin. Unfortunately I had to read very weird things about it and so I think it’s time to write about what it means that I am no longer maintainer of KWin.

First of all: I’m not leaving KDE. I’m still contributing in form of code, bug management and reviews. And I intend to continue to do this.

Second of all: I did not step down as maintainer because of the VDG or the usability group. I understand that my mail read like this, but it’s not the case. That I would step down as maintainer was inevitable and I’m sure it didn’t come as a general surprise to my fellow Plasma and KWin hackers. Personally I decided to step down as maintainer once the Wayland port is finished years ago. In my opinion KWin reached that state about two years ago. I continued to be maintainer to prepare for a good hand over. I deliberately reduced my involvement and passed responsibility to others. This was a long process and worked great in my opinion. As an example I want to point out the new and awesome blur effect introduced in 5.13. My first comment on the phabricator code review was that I’m not going to review it, but leave it to others. I think the result is great and I’m very happy how this worked out.

Over the last year I thought a lot about passing on the torch for maintainership. I realized that I contribute less and less of code but are at the same time blocking many changes due to me reviewing the code and giving a nak or through inactivity by just not reviewing the code at all. In KDE we have a saying: “Those who do, decide”. I realized I’m not doing enough anymore to decide. This results in the timing of me stepping down: I once again nak’ed a change and afterwards realized that I cannot do this. Either I need to actively veto a change I consider wrong and by that anger those who do or step down as maintainer. I decided that I don’t want to be the grumpy old conservative who is against progress and thus did the only logical consequence. It was inevitable, I would have stepped down as maintainer in the next half year for personal reasons anyway, it was just a little bit sooner to help those who are currently working on improving our products.

For KWin this means a significant improvement. A maintainer who is not responsive to reviews is not helpful to the project. By stepping down I give others the possibility to accept changes and nobody needs to wait for me to acknowledge changes. This is especially important for new contributors who we want to integrate better. Also for me personally it is a great improvement as it takes away a lot of burden for not reviewing the code. I now feel way more relaxed to do code changes I’m interested in and chiming in to reviews where I feel like I want to say something. And at the same time I can ignore other review requests as I know there will be a good review on them and it won’t depend on me. Also KWin is currently in a great position to step down as maintainer. We have more developers working on KWin than we had for years. KWin is in a great shape and I’m very positive about the future.

I read a few comments where users expressed the fear that the quality of KWin would suffer by me stepping down. I feel honored that users think I acted positively to the quality. Personally I am quite certain that the quality of KWin won’t suffer. As example I present you the 5.13 release with more user visible changes in KWin for years and me hardly contributing anything to that. Also KWin has an awesome test suite which would catch regressions.

On the other hand I read some disturbing comments about NVIDIA support getting improved by me stepping down as maintainer. Let me assure you that I never blocked any change which would be NVIDIA specific. In fact I encouraged NVIDIA to implement the changes required to get EGL stream working in KWin. Unfortunately NVIDIA has not contributed such patches.

Now a few words on how I maintained KWin. My aim as maintainer was to hand over the code to the next maintainer in a better shape than how it was when I became maintainer. I hope that I could contribute to this aim and many of my decisions as maintainer were motivated by that aim. I learned what went well in past KWin and tried to apply the lessons from it. I considered KWin as a standalone product inside KDE Plasma and judged changes from the perspective of a window manager. One of my highest rules was: no workarounds! No workarounds for broken applications, no workarounds for broken drivers and no workarounds for Plasma. No matter how many users a software has, KWin won’t add workarounds. This applies to software such as Spotify, Chromium and even GTK. If the applications or toolkits are broken, they need to be fixed, so that it works in all window managers and not just in KWin. With the time I found workarounds, e.g. for Netscape Navigator. Of course such workarounds don’t make sense, but clutter the code and negatively affect all users. Or there were workarounds for kdesktop and kicker (the KDE 3 panel, not the Plasma 5 menu). KWin is older than Plasma and I expected that Plasma would evolve and change (which did happen with Plasma 5, Plasma Active and Plasma mobile). KWin needs to be flexible enough to handle such evolution without having to rely to workarounds. Thus if something was needed we did the proper solution instead of finding fast workarounds. I think that the refusal to add workarounds helped the product KWin to achieve the level of quality we have today. Of course it results in disappointed users – as an example the NVIDIA users who would like to have a better experience – but in the long term all users benefit from the strict and hard line I used to maintain KWin.

I also learned that the number of options is a problem in KWin. We have optional features with even more optional features. Over the years I noticed that most of the breakage is in such areas. By trying to do too much we degraded the usability and quality of KWin. I reacted to this by making KWin more flexible and allow users to influence how they like to have KWin without having to carry the code in KWin. The result is KWin scripting, scripted effects, Alt+Tab QML switching themes and in general moving all of the UI elements to QML. This allowed us to streamline KWin and provide a high quality for the areas we offer, but at the same time give users the full flexibility to adjust KWin as they need. Simple by default, powerful when needed.

On the other hand this of course did not go well with all users. Many users requested features and my general response was: no. Any addition to KWin should go through scripts and be maintained by users. Of course not every user understood why they should fork an effect just to get another option. Or why I said no to a contributed patch. But in the end I think this helped to keep the quality high and have KWin in a maintainable state. In that sense I understand that not every user appreciated how I maintained KWin. The hard rules I applied in bug reports unfortunately created tension and the community working group had to step in more than once. For those users hoping that they can get their pet bugs resolved now that I stepped down as maintainer: I’m sorry to disappoint you. I still go through the bug reports and will continue to manage them the way I did as maintainer as long as my successor decides to apply different rules for maintaining KWin.

Last but not least a few words to my criticism on the VDG and usability project. First of all I need to apologize for mixing this in my mail about stepping down as maintainer. I should have raised my concerns at a different time as this was unfortunately received as I stepped down due to conflicts. I’m somebody who speaks up when he feels things go wrong. Given the way how I maintained KWin as explained above this creates tension with the usability project. My aim is to not implement every feature request and move the responsibility to users while the usability project tries to implement everything which makes users happy IMHO. This is obviously a clash of cultures and due to that I very often had to take an opposite position to what the usability project tried to achieve. I raised my concerns quite often. For me it was personally difficult to hold up such a position over a long time. Due to that as explained in my mail I lost motivation to review changes. My mail was mostly to explain why I lost motivation and I think to those in Plasma who know how I maintained KWin and what my aims are this was understandable. I was very unhappy on how this got communicated in some news postings and social media. As all those internal information were missing. I urge users to keep project internal discussions to the projects.

What I want to point out is that I really appreciate the work the usability project and also the VDG are doing. They are super enthusiastic and try to bring our software to the next level. I do not disagree with their work. The criticism I expressed in my mail was focused on the process and the transparency on how decisions are made. That’s where I personally see the need for improvements. What’s quite important to me is to point out again that those two projects are not responsible for me stepping down as maintainer.

Thank you.

I found this construct some time ago. It took some reading to understand why it worked. I’m still not sure if it is actually legal, or just works only because m_derivedData is not accessed in Base::Base.

struct Base {
    std::string& m_derivedData;
    Base(std::string& data) : m_derivedData(data) {
    }
};

struct Derived : public Base {
    std::string m_data;
    struct Derived() : Base(m_data), m_data("foo") {
    }
};

When you write code in QML, ListModel is a handy class to quickly populate a list with data. It has a serious limitation though: the values of its elements cannot be the result of a function. This means you cannot write this:

import QtQuick 2.9
import QtQuick.Window 2.2

Window {
    visible: true

    ListModel {
        id: speedModel
        ListElement {
            name: "Turtle"
            speed: slowSpeed()
        }
        ListElement {
            name: "Rabbit"
            speed: highSpeed()
        }
    }

    Column {
        Repeater {
            model: speedModel
            Text {
                text: model.name + " " + model.speed
            }
        }
    }

    function slowSpeed() {
        return 12;
    }

    function highSpeed() {
        return 42;
    }
}

Running this will fail with that error message: "ListElement: cannot use script for property value".

A first workaround: use a JavaScript array

The first workaround to this limitation I came up with was to replace the ListModel with a JavaScript array, like this:

import QtQuick 2.9
import QtQuick.Window 2.2

Window {
    visible: true

    property var speedModel: [
        {
            name: "Turtle",
            speed: slowSpeed()
        },
        {
            name: "Rabbit",
            speed: highSpeed()
        }
    ]

    Column {
        Repeater {
            model: speedModel
            Text {
                property var element: speedModel[model.index]
                text: element.name + " " + element.speed
            }
        }
    }

    function slowSpeed() {
        return 12;
    }

    function highSpeed() {
        return 42;
    }
}

This works fine, but has two limitations.

First limitation: you can't use the model as usual in your delegate because model.index is the only piece of information available, hence the need for the element property (Actually, I wish the variable representing the data inside a delegate were always called element instead of model, but that's another story...)

Second limitation: you can't manipulate the data afterwards. If you add an element to the array, the view is not going to display it.

Second workaround, initialize ListModel from a JavaScript array

Instead of passing a JavaScript array to our view, this workaround uses a ListModel, but initializes it using JavaScript:

import QtQuick 2.9
import QtQuick.Window 2.2
import QtQuick.Controls 2.2

Window {
    visible: true

    ListModel {
        id: speedModel
        Component.onCompleted: {
            [
                {
                    name: "Turtle",
                    speed: slowSpeed()
                },
                {
                    name: "Rabbit",
                    speed: highSpeed()
                }
            ].forEach(function(e) { append(e); });
        }
    }

    Column {
        Repeater {
            model: speedModel
            Text {
                text: model.name + " " + model.speed
            }
        }
        Button {
            text: "Add"
            onClicked: {
                speedModel.append({name: "Bird", speed: 60});
            }
        }
    }

    function slowSpeed() {
        return 12;
    }

    function highSpeed() {
        return 42;
    }
}

This approach avoids the two limitations of the previous workaround: the view can use the model as usual, which is nice especially if the model and the view are not defined in the same file. And we can modify the model as we usually do.

I tried to simplify the forEach() call to forEach(append) but hit another error: "QML ListModel: append: value is not an object". Don't know why this happens, if you have the answer I would love to hear it.

You can make the declaration less verbose by representing elements using arrays instead of objects in Component.onCompleted, like this:

Component.onCompleted: {
    [
        ["Turtle", slowSpeed()],
        ["Rabbit", highSpeed()],
    ].forEach(function(element) {
        append({
            name: element[0],
            speed: element[1]
        });
    });
}

It's an interesting approach if you have many rows and few columns. You still get named fields in the view, so you don't loose any readability.

That's it for this article, I hope it was useful! Here are the source files if you want to play with them: fail.qml, jsarray.qml and listmodel-js-init.qml.