KDevelop 5.4.3 released

kossebau Mon, 2019/10/21 - 18:31

At this year’s KDE conference Akademy we discussed how to evolve Kate over the next years. One of the areas we want to improve is better git integration out of the box. Currently, Kate ships the Projects plugin, which automatically detects and loads your file structure from your git repository. If a project is loaded, then the Search & Replace plugin allows to search&replace in all project files. In addition, the Quick Open feature also supports opening files from the currently active project - all explained here.

However, the Projects plugin does not provide any real git integration: You can neither pull nor push, commit, diff, etc. If at all, additional git functionality is available only via external tools like gitk or git-cola (e.g. available in the context menu).

This is something we would like to change by having really nice git integration.

Using Existing Git Clients

Since we don’t have the resources to start a git client from scratch, we had a quick look at existing git clients, preferably written in C++ and Qt5. What we found so far:

GitQlient and QGit

Back in 2007, the Qt-based git client QGit emerged. QGit is still alive and maintained. However, no new major features seem to be added either. QGit is licensed under GPLv2.

Just some weeks ago, two blogs appeared on planet.qt.io about GitQlient, which is a fork of QGit. As discussed in part 1, the idea of GitQlient is to have a nice widget that can be embedded into Qt Creator. This idea is elaborated a bit more in the follow-up part 2. The GitQlient additions are licensed under LGPLv2+, but given it’s based on QGit, the effective license is GPLv2 only for now.

What’s nice about GitQlient is that it is Qt5-based and uses just 74 .cpp/.h files, and has only a total amount of 11393 source lines of code (slocs) including API documentation and empty lines. So it’s not that much code, which is good maintenance-wise. However, both QGit and GitQlient currently are one-man shows, so the developer base is rather small at the moment.

gitahead - Understand your Git History

Another Qt5-based git client that caught our attention is gitahead. gitahead seems to be a full-feature git client with many features. What’s very nice about gitahead is: It’s licensed under MIT license. However, the source code is much larger: ~52000 slocs. In addition, the 3rd party dependencies include e.g. scintilla and many other libs, adding another ~184000 slocs. Compared to QGit/GitQlient this is 20 times more, and many dependencies we certainly would not want in Kate.

Join the Discussion

At this point, nothing is decided yet. As it currently stands, GitQlient looks a bit more promising, since it’s simply much smaller code-wise and therefore likely easier to adapt to Kate. If we decide to give GitQlient a try, I’d like to contact the initial and current QGit authors to try getting it relicensed from GPLv2 only to GPLv2+ or even LGPLv2+.

If you know of any other Qt-based git clients that can nicely be integrated into Qt/Kate, then please join the discussion at the KDE subreddit.

Every once in a while I need to do a fresh installation (usually because of new hardware) and then I encounter this:

This is a long-known bug with countless Reddit/Forum/… posts with often the correct answer how to fix it.

So what I decided to do is to make a package that does that semi-automatically:

Basically the problem is: When there’s no “default” set in /usr/share/icons/, Plasma or KWin or whatever doesn’t always pick the selected cursor set (happens only under X11, not Wayland) and this package simply installs a default theme that contains no cursor files and merely inherits Breeze.

Here’s the source code if you want to make sure nothing nefarious is going on.

Plasma 5.17 was released this week to glowing reviews! As with most new releases, our loyal users wasted no time in finding all the bugs we missed! So you know what that means, right? We all burned the midnight oil fixing the problems you found, and Plasma 5.17.1 will be released in just a few days with everything we’ve knocked out so far (detailed below) so never fear!

New Features

• The System Settings Widget Style page now has a shiny new grid-style user interface that follows the new format and looks and works much better (Kai Uwe Broulik, Plasma 5.18.0):
  
• The weather widget now shows windy conditions with fancy new icons (me: Nate Graham, Shawn Starr, and Carson Black, Plasma 5.18.0 and Frameworks 5.64):
  

Bugfixes & Performance Improvements

• Clicking the “Defaults” button in the System Settings Global Shortcuts page no longer erases all the Task Switcher shortcuts (David Edmundson, Plasma 5.12.10)
• The new startplasma-* apps no longer break multi-line shell functions and environment variables (Fabian Vogt, Plasma 5.17.1)
• When you plug an external screen into a laptop, close the laptop’s lid, and then re-open it, the laptop’s screen is now re-enabled as expected (Nicolas Fella, Plasma 5.17.1)
• Certain System Tray icons no longer have an ugly black background (Konrad Materka, Plasma 5.17.1)
• Non-critical notifications are no longer inappropriately suppressed when an external screen is connected to a laptop and the laptop’s built-in screen is disabled (Kai Uwe Broulik, Plasma 5.17.1)
• Some GTK2 apps no longer look weird after using another GTK2 app with global menu support (Fabian Vogt, Plasma 5.17.1)
• When one screen is a replica of another, the name of the replicated screen is now shown properly in the System Settings Display Configuration page (me: Nate Graham, Plasma 5.17.1):
  
• The NOAA environmental visualization picture of the day wallpaper now works again (they keep changing the structure of their website so parsing keeps breaking) (Yunhe Guo, Plasma 5.17.1)
• In the System Settings Display Configuration page, the rotation icons no longer have huge borders and mis-positioned tooltips (David Edmundson, Plasma 5.17.1)
• The “bouncing app icon” effect (which can be disable if you hate it, BTW) is now scaled to the proper size when using High DPI scaling (Kai Uwe Broulik, Plasma 5.17.1)
• When the version strings in Discover’s Updates page become shortened because there’s not enough space to display everything, they now return to their full forms when the window is resized to add additional space (me: Nate Graham, Plasma 5.18.0):
  
• The System Settings Compositor page no longer crashes in certain circumstances (David Edmundson, Frameworks 5.64)
• Media icons throughout Plasma are no longer subtly blurry (Noah Davis, Frameworks 5.64)
• Accessing remote Samba shares is now more accurate when you enter the wrong password (Harald Sitter, Frameworks 5.64)
• KOrganizer is once again able to find and downloads add-ons (Allen Winters, Kontact 19.08.3):
  
• When Konsole is used outside of Plasma, its scrollbar no longer floats over the left side of the window (Mariusz Glebocki, Konsole 19.12.0)
• Search results in Discover are now more accurate, particularly for exact matches (Aleix Pol Gonzalez, AppStream 0.12.10)

User Interface Improvements

• Previews in the System Settings SDDM theme chooser page are no longer ugly when using a high DPI scale factor (David Edmundson, Plasma 5.17.1)
• The System Settings Display Configuration page now lets you switch between the settings for multiple connected displays using a combobox (Kai Uwe Broulik, Plasma 5.17.1)
• Discover’s “Updates are available” notification is no longer persistent and once again disappears on its own, because there’s already a persistent thing in the System Tray when updates are available (me: Nate Graham, Plasma 5.17.1)
• The Plasma Audio Volume applet now uses an outline-style star icon for the “Default Device” buttons corresponding to non-default devices (me: Nate Graham, Plasma 5.18.0):
  
• The scale factor value in the System Settings Display Configuration page is now expressed as a percentage rather than a decimal, and now limits the increments to 6.25% on X11, which minimizes visual glitches in applications (this restriction is not present on Wayland, which is able to handle a broader range of scale factors) (me: Nate Graham, Plasma 5.18.0)
• The System Settings Thunderbolt Device Management page now shows a placeholder message in the device list when it’s empty so you don’t think it’s broken (me: Nate Graham, Plasma 5.18.0):
  
• You’re now warned when launching a new Windows executable that can be opened with WINE (Yunhe Guo, Frameworks 5.64)
• Dolphin no longer tortures you by displaying advanced search options that won’t work when you’re searching in a non-indexed location; instead they’re just hidden instead (Ismael Asensio, Dolphin 19.12.0)

How You Can Help

Check out https://community.kde.org/Get_Involved and find out ways to help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

I’ve been working on Calamares, the Universal Linux Installer, for a little over two years – following up in the role Teo started. It’s used by Neon (for the dev version, not the user version) and Manjaro and lots of other Linux distributions. I’ve typically called it an installer for boutique distro’s, as opposed to the Big Five.

Well, Debian 11 has plans. And lubuntu uses it as well (and has for over six months).

Those seem pretty big.

This does not change the way Calamares is developed (much), really. The same principles apply as with each recent release.

• PRs are welcome. Really! Especially if you have something specific to implement, or specialised knowledge. I’ll quibble about code formatting and style and possibly encourage you to do things in a more general fashion, but most PRs are good.
• Well-written feature requests get attention (drop in on IRC to talk about them).
• Regressions get fixed now (if I understand your bug report).

I consider Calamares development to be collaborative, and I’m mostly here to deliver the things that distro’s downstream need (since my “own” distro would be FreeBSD, and that’s a long-long-term project with Calamares).

It is time for another installment of Godot (previous entries: introduction, 2D). This time, I have dived into the world of 3D. The goal is to recreate parts of an old time favorite: Kosmonaut. Something I remember playing a lot on my dad’s 286 with amazing EGA graphics.

The state of the game when writing can be seen in the short screen capture below. This is more of a tech demo status than a full game at the moment, but I hope you will still find it interesting. You can also get the complete source code.

The project is split into two major parts: the Player and the World. Each of these contain scripts that I will refer to below. But first I want to talk about how to create 3D scenes.

Of course every scene can be created manually from individual elements. However, in 2D games it is common to use tiles to create large worlds from common elements. Godot’s analog in the 3D world is the GridMap.

A grid map is more or less a 3D tile map. Inside each tile (or cell, or whatever you call them in 3D) you can place an item. The way you create these items in Godot is to place each 3D element in a scene and then convert it to a mesh library. Then you can draw your 3D scene much like you can draw a 2D scene from tiles.

Once we have a world with a track (the grid map), we add a player to the scene (the yellow blob in the image above – I need to learn Blender to create a proper ship). The player scene contains the ship – and the camera. This means that the camera follows the player automatically – very convenient.

The player script is responsible for this ship’s movements based on user input. Inputs can either be pressed for a long time, used for sideways movement, or just tapped (i.e. the release is ignored), used for jumping. Each of the inputs are mapped to a keyboard key (or other input device) in the Project Settings dialog, under the Input Map tab. This feels a bit awkward to me and makes me lose the feeling of flow – but I don’t know how to do it better.

Getting gravity, jumping and bouncing to work was fun. It reminded me of coding games on my Atari ST. The character controller code is really basic, but can become super complex if one does not think through the order of the things you do. I ended up exporting some tunables so that they can be adjusted in the editor, just to figure out how high to jump and how fast to run the ship.

Figuring out crashes was easier than expected. Through the KinematicCollision objects retrieved using get_slide_collision, the normal of the surface collided with can be retrieved. From there on, it is easy to determine if the ship is sliding along a wall, or just hit it head on. The latter is deadly and the crash signal is emitted.

The crash signal leads to the world script. Here we handle the second death scenario – falling. This is a handled by the world, rather than the player, as the world knows what the lowest possible y value is.

The world also refers to two invisible scene elements used to mark the starting position ($StartPosition) and goal position ($GoalPosition). The first is used when resetting the player, while the latter is used to determine when the goal has been reached (duh).

When starting a run – or restarting for the millionth time, and when completing a track, a short sequence is shown. These sequences are realized using a CanvasLayer, Sprites and an AnimationPlayer. The canvas layer allows us to add 2D contents on top of (and behind) a 3D (or 2D) scene. Each such layer is broken into a scene of its own that encapsulates one sequence. Each scene have a small script interface with a play function and a finished signal.

When showing a sequence from the main world script, the script is started and then the calling function yields until the finished signal is emitted, as exemplified here. Very convenient!

One more word about the sequences: the animation player is a really convenient way to control all properties of a scene using key frames. It can even be used to call functions. I really like this.

On a side note, I found my first Godot docs bug when writing this post. The pull request is right here ;-)

Akademy 2019 was hosted in University of Milano-Bicocca, Milan from 7th to 13th September. It was great to meet all the fellow KDE contributors again

Akademy gives a chance to bring together artists, designers, developers, translators, users, writers and other contributors to meet in person and discuss about achievements of the past year and plan out the goals for the next year.

Group Photo

First two days contributors presented talks on their respective projects. You can go through the talks as now the videos for the same are available.
All talks were so great and full of knowledge, but out of all there were few topics that fascinated me, and I would like to share those topics with you.

• Everything to hide: helping protect the privacy of our users by Ivan Čukić.
• All on board ! Are we there yet? by Neofytos Kolokotronis.
• Plasma for Embedded Devices by Marco Martin and Bhushan Shah.
• Taking KDE to the Skies:Making the drone ground control kirogi by Ekie Hein
• And my favorite talk was the KDE Goals – Panel Discussion hosted by Lydia Pintscher.

Last year in Akademy, KDE Goals were announced, which were:

1. Usability and Productivity for Basic Software.
2. Privacy Software.
3. Streamlined Onboarding of New Contributors.

So in this Interactive Session, Lydia discussed with the goal keepers how far they have reached and how was their experience while working on these goals, and then finally this year’s Goals were announced,

• Wayland
• Consistency
• All about the apps

This year unfortunately I didn’t give any talk but instead tried my hands in volunteering. I volunteered to be a Session-Chair, basically my job was to introduce speaker and manage talk room. It was such a learning and amazing experience to be a volunteer.

Having a word with the Keynote speaker Leonardo Favario.
{Photo credit Paul Brown}

Rest of the week was BoFs (Bird of Feather), Workshops, Meetings, Daytrip and Training.

There were many BoF sessions scheduled for a week and I attended the following sessions:

KDE PROMO :

We discussed on some marketing strategies, and did some brainstorming on few topics. Learnt how far we have reached on spreading KDE to new users and determined few tasks we would work on for this year.

OpenQA :

I work and contribute in OpenQA Project, in this session Harald Sitter and Jonathan Riddle gave a brief introduction on OpenQA and then we discussed the workflow for writing new tests cases, and I personally got a chance to learn alot of new things from Jonathan Riddle.

KDE India :

We discussed on next KDE Conference India, listed few places were we can host the conference, and I am happy to announce that conf.kde.in is coming back in 2020 It will be held in Maharaja Agrasen Institute of Technology from 17th to 19th January. If you love open source and wish to learn more about our community come join us in this conference

Privacy :

In Privacy BoF we discussed on various aspects, determined goals for this year, talked a bit on funds for next sprint and did brainstorming on few topics.

KDE Students Program :

Here we discussed about the students program, took feedback on what we need to improve, what should be the work pattern for this year and our main focus was on Season of KDE Program, It is an upcoming project so we were discussing on its timeline and structure which soon you will come to know

Daytrip

It is a tradition of Akademy that Wednesday afternoon we all attendees go out and explore a particular area. This time the trip went to the North to Varenna near Lake Como, Ahhh! it was indeed the most magnificent place, a day where I enjoyed the nature’s beauty accompanied with my incredible friends.

Enjoying Daytrip

Training

Communication Training:

KDE e.V. had organized Communication Training session for community members, and I am so glad I could attend this training. Our trainer Tilman Krakau gave some basic but very essential lessons on communication, how to coordinate with your team-workers and always try to understand the receivers’ point of perception.

Conclusion

Akademy was really productive, it was great socializing and meeting old friends and making new ones. Learnt alot of new stuffs and it was an amazing experience. I am really thankful to the KDE e.V. for sponsoring my trip.

And to those who aren’t part of KDE yet and wish to be, I have something interesting to share with you, Season of KDE is coming soon. It is a great way to join our community, learn new things and get comfortable with coding, and there is one thing I would like to tell about this program, it is just not for students it is open for everyone

See you all next Akademy, till then Happy Coding!

 

 

Thanks to the awesome KDE community, we are happy to present the Plasma Mobile project’s third weekly update.

Shell User Interface

David Edmundson backported some Qt Wayland patches that improve the overall stability of the shell.

Marco Martin added further refinements to the shell.

Kaidan

Jonah Brüchert replaced the custom contacts search field by the recently added Kirigami search field in Kaidan. The search is accessible by using the search action or by pressing Ctrl+F as usual. Robert Maerkisch improved the performance of the search by using a proxy model instead of hiding contacts from QML. Apart from that the contacts are now sorted chronologically and secondarily also alphabetically thanks to Linus Jahn.

Kirigami

Kirigami apps no longer show an empty context drawer in certain circumstances (Nicolas Fella).

Marco Martin fixed the Kirigami drawer handles on Plasma Mobile.

KBibTeX

Thomas Fischer has started work on a mobile-friendly BibTeX client.

Dialer

Nicolas Fella made sure that an appropriate message is shown when no contacts could be found.

Settings Application

The code for the settings applications received a small cleanup. Names of various settings entries have been adjusted to be more concise: they now show “Foo” instead of “Configure Foo” in the top bar.

Calindori

When creating or editing an entry, saving is now the most prominent action.

Angelfish

Angelfish, the browser, has seen some refactoring by Jonah Brüchert which avoids loading all kinds of dialogs (authentication, webrtc permissions etc) at startup and loads them when needed. This should result in reduced startup times.

Input of urls in its settings is now converted into proper urls, to make sure for example the homepage can actually be loaded even though the user did not enter https://kde.org but just kde.org.

Maui Project

The file browser component has gained improvements for focus chaining, keyboard navigation and new keyboard shortcuts. The places list can now browse all available tags. Files now keep their associated tags even when renamed or moved. Furthermore it now supports copy/pasting files into/out of the app.

The file previewer now uses Okular to preview any document supported by Okular.

The browser view has an improved Miller Column view and its model features improved performance by only adding or removing the necessary paths.

The MauiKit framework and some Maui apps can now be built for Android using CMake in addition to qmake. This allows building Index and vvave using the KDE Binary Factory and making them available in the KDE F-Droid repository (Nicolas Fella). This allows you to test some of the Plasma Mobile apps even without a Plasma Mobile device. MauiKit gained initial support for handling system accounts in a more integrated way by using libaccounts on Linux.

MauiKit parts now have been separated into components to allow having lighter builds when using static linking. Those components are: Editor, Filemanager, Tagging, Syncing, Accounts, Terminal and Store.

When using qmake, MauiKit now automatically fetches all the needed extra binaries, library sources, and assets needed to compile when statically linking.

vvave’s codebase has received some cleanups and improvements.

Want to be part of it?

Next time your name could be here! To find out the right task for you, from promotion to core system development, check out Find your way in Plasma Mobile. We are also always happy to welcome new contributors on our public channels. See you there!

At least twice I have been to India. Atil Chitnis closed FOSS.IN in 2008, and I wrote about that only briefly, and in 2011 there was conf.kde.in in Bangalore which I wrote about some more.

During one of those conferences I fell asleep on the ground in the hall at the KDE booth.

But there’s a new conf.kde.in happening at the beginning of 2020. You can read more on the dot. Based in Delhi this time, the conference remains true to its roots:

conf.kde.in is a platform for Qt/KDE contributors, developers and enthusiasts to come together, share their knowledge, contribute, learn and play.

Kai-Uwe has made a badge that, frankly, rivals my own kolourpaint prowess:

Now, I’m not going yet. Like everyone else, I go through the call-for-papers process (which means thinking up things to talk about!). You can find the link on the site, along with other information (you’ll need a KDE identity account).

During one of those conferences there were monkeys.

For me personally, it’s weird and inspiring seeing conf.kde.in return. I remember the excitement of an own conference in India, of first shirt designs, of The KDE Handbook which Pradeepto put together with the enthusiasts of the time (I still have my copy). The amazing “we’ll make it work” attitude to conference organization which seems to be a hallmark of KDE events to this day.

If you watched the Akademy BoF summary videos this summer, you saw the results of the KDE India BoF, which included planning – starting the planning – of this event. And now it’s here.

So watch the site, write a proposal, and be there!

Announcing a small update for the goal: KDE is All About the Apps. kde.org/applications is now listing the stores where the application is available. For the moment, it’s only listing Linux and the Windows Store, but support for F-Droid and the Play Store is planned. Stay tuned!

Hi there,

The seventh edition of the KDE Latin-American Summit (LaKademy 2019) is ready to go! It will take place at Salvador-Bahia, northeastern Brazil, from 14th to 17th November. 24 participants, hopefully accompanied by some local guests, will meet at Information Technology Superintendence of Federal University of Bahia for four days of hacking sessions, promo meetings, and all sort of KDE-related things.

Salvador (the city I live in) is well known for its beatiful beaches, the biggest carnival in the planet, and its unique cuisine. In November, attendees can already have a glimpse on our warm summer and hopefully that will bring a bunch of additional energy for having a fun and productive meeting.

Salvador - Bahia - Brazil

Stay tuned for the upcoming news of our achievements at LaKademy 2019. Many thanks to Angela Cunha for coming up with such a nice LaKademy 2019 logo and to the KDE e.V. for supporting the meeting.

See you!

K', Hot off the presses, here's some New Stuff for you, with the Quickness! ...terribly sorry about that, i shall endeavour to do better. Let's try that again.

As of KDE Frameworks 5.63, released on 2019/10/12, we officially introduce the fruits of my labour over the last few months, the shiny, new Qt Quick components, which were created to bring the Qt Quick submodule of KNewStuff up to par with the old QWidget based UX. Not only that, they also bring with them some shiny, new abilities in KNewStuff, which previously did not have any concept of comments outside of the very basic information of how many a content item had (which, incidentally, was also incorrect, and had been since, well... since that code was written about a decade ago - guess nobody noticed, because the information is a bit useless on its own).

Before running off and explaining what's what, have a video of my presentation from Akademy 2019, where i gave an overview of the new components and functionality:

Now, before you hop over to the API documentation and start digging in to work out how to actually use all this hot new stuff really quickly (sorry), here's a really quick visual rundown of some of the shiny stuff:

You know this. It's the KNS::Button button, but now more Quick [API]. Don't use this unless you're doing some porting, keep going...

The dialog we all know and love, but with a twisty twist and shiny new tile types [API] Don't use this either (with a similar caveat), use the next thing instead!

The new Page. The new intended central access. Shown here in the similarly new test tool. [API]

The entry details dialog, except as a Kirigami Page [API]

A lot of entries have multiple options for stuff to get - the DownloadItems Sheet shows those. [API]

You want comments? We got comments! All automatic, except if you feel like doing something much deeper. Have a model. [API]

Authors are important. So we should trust what they tell us they're called, and what they look like, right? Anyway, a super easy data provider Component for Author information. [API]

When you have a UI-less library that needs to get some feedback from the user, what do you do? Well, KNewStuff uses a QuestionAsker system. [API]

If you (like Peruse) was already using the old Qt Quick components List and Item, they still work just fine. In fact, finer than they did before by a fair chunk. Do consider using the Page, though. [API]

i hope you have enjoyed your screenshots and videos ;) Now go forth and implement getting that hot new stuff in your Qt Quick applications!

Also don't hesitate to mention, when you discover it, the various holes in the documentation that undoubtedly are there, so that we might get those fixed. Even better yet, we are very happy to take patches over on Phabricator, both code and documentation ones. One thing that i know is missing is a porting guide, to help people transition from the old QWidgets based stuff to the Qt Quick components for people who have got applications they're looking to port or are already porting.

---

The word of the day is: Shiny. Because shiny things are neat ;)

As mentioned, I’ve started using Godot to create some games with my kids. We decided to start with something simple, so we created Super Memory. I’m still waiting for a graphics delivery, so right now the you play with “dad’s placeholder cards”. They aren’t pretty – but they get the job done.

I had three major goals when creating this game:

1. Teaching the kids basic programming logic – how to think like a machine.
2. Teaching myself a bit about Godot.
3. Creating a game that I can push all the way to Google Play.

The first two items are done – for the third I’m still waiting for the graphics delivery. Kids are such lazy team members ;-)

When it comes to the game logic, I decided to push it all into the entry point of the game: the table scene. The main parts are in the init_game function and the _on_card_flipped function. I would consider the rest of the code support functions, or GUI driving functions.

This brings me to the GUI parts. I’m still not convinced that I understand how to properly layout stuff using Godot, but at least it looks ok now – at the cost of some fixed element sizes and such. I need to spend some more time to really understand how the anchoring and stretching really works. I guess I have a hard time wrapping my head around it as the approach is different from what I’m used to from Qt.

Looking at the rest of the code, I’ve tried to make all the other scenes (in Godot, everything is a scene) like independent elements. For instance, the card scene has a face, and an is_flipped state. It can also signal when it is being flipped and clicked. Notice that the click results in a signal that goes to the table scene, which decides if the card needs to be flipped or not.

The same goes for the GUI parts. They simple signal what was clicked and the table scene reacts. There are some variables too, e.g. the number of pairs setting in the main menu, and the points in the views where that is visible.

All in all, the code is quite messy. I’m getting used to GDScript, so parts of the code has static typing information, while others don’t. Also, naming and underscore prefixing is a bit random. I’m also a bit unsure about the onready var pattern to hold references to various scene elements vs hard coding the reference. And one more thing – some parts are in Swedish before it all shifted to English.

At the moment, I have built installers for all desktop platforms and tried them. I’ve also setup an Android toolchain and pushed development builds to a couple of phones. This also works beautifully. Next step is to get the graphics delivery and push something to Google Play. I will keep you posted.

In the last few years I have come across the CLA topic several times. It is and will be a popular topic in automotive the coming years, like in any industry that moves from being an Open Source Producer towards becoming an Open Source Contributor.

In my experience, many organizations take the CLA as a given by looking at the google, microsoft or intels of the world and replicate their model. But more and more organizations are learning about alternatives, even if they do not adopt them.

What I find interesting about discussing the alternatives is that it brings to the discussion the contributor perspective and not just the company one. This enrichs the debate and, in some cases, leads to a more balanced framework between any organization behind a project and the contriibutor base, which benefits both.

Throughout these years I have read a lot about it but I have never written anything. It is one of those topics I do not feel comfortable enough to write about in public probably because I know lots of people more qualified than I am to do so. What I can do is to provide some articles and links that I like or that have been recommended to me in the past.

Articles

• “Why you probably shouldn’t add a CLA to your open source project“, written by Ben Alter back in 2018 is a must read. Ben is a United States-based lawyer who works for GitHub as their “evangelist” to government agencies.
  • “CLAs are Not a Sham” by Kyle E. Mitchell, a lawyer, is a respond to the previous article.
• “The trouble with Harmony: Part 1 and Part 2″ by Richard Fontana 2011, a Red Hat lawyer. He came back to the topic this year (2019) in his article “Why CLAs aren’t good for open source” summarising Red Hat’s position.
• “Why Your Project Doesn’t Need a Contributor Licensing Agreement” by by Bradley M. Kuhnon June 9, 2014. Bradley is a well known member of the Software Freedom Conservancy.
• “Contributor Agreements Considered Harmful” by Eric S. Raymond on July 8, 2019, represents a clear view from the individual contributors perspective on the CLA topic.
• “Community contributions and copyright assignment” By Jonathan Corbet, October 28, 2009. This article analyses from the contributor’s perspective the Canonical Ltd CLA which started a heated debate back then, leading to the Harmony project creation first and the initiative by the Mark Shuttleworth Foundation later on, two of the main attempts to standardise CLAs up to date.
• “Some thoughts on Copyright Assignment” by Michael Meeks, 2011, is still one of the most relevant articles on the topic, covering not just the theory but also putting examples of how harmful unbalanced relations with an entity that controls an Open Source project might be for contributors. Specially relevant has been over time the Recommendations section of this article.

DCO

It is impossible nowadays to talk about CLAs without talking about DCO (Developer Certificate of Origin). Here are some articles that I find interesting:

1. Ben’s Cotton article “CLA vs DCO What’s the difference“, from 2018 is a good article to read because it does not favour one over the other one.
2. I like the article “CLAs and using DCO clearly” from Hen written back in 2018 because it summarises well the costs associated to CLAs and how they (do not apply) apply to the DCO.
3. It is worth reading the summary of James talk at Linux Foundation Collaboration Summit 2014, “The most powerful contributor agreement” done by Jonathan Corbet.
4. Julien Ponge wrote “Developer Certificate of Origin versus Contributor License Agreements” back in 2016.

For companies that “do not buy into the anti-CLA” case, R. Fontana propose another two options:

1. Eclipse Contributor Agreement
2. The Software Freedom Conservancy’s Selenium CLA, which are not proper CLAs but DCOs in his view.

FLA

It is always interesting to learn about the Fiduciary License Agreement FLA, developed by the FSFE:

1. Fiduciary Programme
2. FLA FAQ
3. FLA-2.0 announcement.

Inbound = outbound

A serious conversation about CLA requires to understand the concept of inbound=outbound:

GitHub explains inbound=outbound as:

• “outbound licensing”, refers to granting a licence to another party to use, copy, distribute…. (depending on the license) your intellectual property.
• ”inbound licensing” means obtaining a licence from another party, to use, copy, distribute…. (depending on the license) its IP for your own consumption (distribution, etc. again depending on the license).

GitHub explains inbound=outbound as:

“Whenever you make a contribution to a repository containing notice of a license, you license your contribution under the same terms, and you agree that you have the right to license your contribution under those terms.[…]“

In the CLA discussion context, the general idea behind inbound=outbound is that the project should make evident to every contributor the contribution conditions, including those related with licenses rights and restriction. The contributor will then contributes her code with the same license, giving little room for later claims, either by the project, the contributor or third parties, based on those conditions being unclear or not easily reachable.

The project license and its description should be prominent and located at least where it is common practice in Open Source to find them. The same applies to all the assumptions and conditions affecting the contributors and the project in this area.

Common practice, many will claim, but sadly some projects are better than others on this.

Who is doing what?

In CLA discussions, it helps to know what others are doing. Here you have some links I have collected over the years and I still find relevant. I have to recognise that in a couple of cases cases I do not remember exactly why they called my attention at the time.

Company driven projects:

• Chef: Introducing DCO
• GitLab: Moving from CLA to DCO
• Docker: Introducing the Docker DC
• Nextcloud: Why I forked my own project and my own company.

Consortium driven projects:

• CNCF:
  • “Now DCO is preferred except for Kubernetes and gRPC.”
  • “Helm, for instance, also moved to DCO.”
• Hyperledger
  • Contribution policy
  • DCO v1.1
• Openstack: “General information about why a not CLA and why yes to a DCoOUS”
• Node.js: Announcement of removing the CLA
• Linux Container Project: LXD requires DCO

Community driven projects

• Eclipse: Eclipse Contribution agreement (a DCO de facto).
• KDE eV FLA.

Organizations with different agreements for individuals and entities:

• GENIVI uses a CLA only for entities and a DCO for individuals.
• OASIS uses a form for the same purpose.
• VMWare CLA FAQ
• Canonical: Individual CLA, Entity CLA and FAQ.
• IBM, for Swift, also uses a different CLA for individuals and for entities.
• Facebook

Organizations with CLA:

• Google
• Microsoft (.pdf)
• Check Wikipedia for more.

Additional links

And finally, I have several links that I think are worth reading for different reasons:

1. Project Harmony is worth investigating as an interesting attempt to standardize CLAs:

• Guide to the contributor agreement.
• How to use the contributor agreement.

2. GitHub uses an Individual and an entity CLA. It is interesting their CLA-assistant.

3. James Bottomley’s ideas about the Corporate Contribution Pledge published back in 2016 as complement to the DCO are worth reading.

Additional suggestions from readers

I hope my effort triggers the contributor in you so you provide additional links or challenge the ones above. I will substitute this text for those links you provide, obviously giving you credit by default. It would be a great way to help others in the future. Thank you very much in advance.

KBibTeX is a bibliography editor (BibTeX and somewhat BibLaTex) used in conjunction with LaTeX and friends. Based on this code base, a SailfishOS client called ‘BibSearch’ exists which allows to search for bibliographic data in various online sources (IEEE Xplore, Google Scholar, ACM Digital Library, …). BibSearch&aposs code makes use of KBibTeX&aposs C++ code, has its user interface implemented in SailfishOS&aposs Silica QML, and provides just two C++ files on its own to glue together everything.

It has long been my goal to provide a QML or Kirigami-based client of KBibTeX of similar functionality, either to be used as Plasma widget or for Plasma Mobile (thus equivalent to the SailfishOS implementation). Finally I have been able to put together an initial implementation using Kirigami2. There are several rough edges and bugs, and much of the intended functionality is missing, but at least one can search for bibliographic data. If you are familiar with Kirigami, it should be a low-hanging fruit to fix the obvious issues, especially given that there is already a Silica-based client as reference. Code contributions to branch feature/kirigami are welcome!

comments

In a recent blog posting I presented some code on how to transliterate common Unicode characters into ASCII-only representations using a offline-generated lookup table to avoid dependencies on ICU which would normally do this job.

By an anonymous commenter, I got pointed to that Unicode (in Qt) is slightly more complicated than I had considered when writing the code: I missed to handle planes beyond the Basic Multilingual Plane (BMP) and the ‘surrogates’ between code points 0xD800 and 0xDFFF. In a series of recently pushed Git commits I addressed problem of surrogates and fixed some more issues. Some preparatory work has been done to support more planes in the future, but as of now, only the BMP is supported. For details, please have a look at the five commits posted on 2019-10-12.

comments

Lots of great backend work happened this week which is very important, but not terribly flashy. And most of the in-progress work I alluded to last week hasn’t landed yet. So I’m afraid the user-visible changes will have to be a bit light this week. But fear not! For Plasma 5.17 is undergoing its last rounds of final polish and bugfixing before the release next week, and work churns along on lots of great stuff slated for Plasma 5.18 and the next apps versions!

Bugfixes & Performance Improvements

• Font anti-aliasing settings are now read and written correctly, so you get slight RGB font hinting by default as intended (Kai Uwe Broulik, Plasma 5.17.0)
• When Discover is loading application screenshots, the loading spinners are now located in the right place (Aleix Pol Gonzalez, Plasma 5.17.0)
• Discover no longer lets you futilely try to cancel update operations that aren’t cancelable (Aleix Pol Gonzalez, Plasma 5.17.0)
• Discover now shows apps’ licenses correctly (Aleix Pol Gonzales, Plasma 5.17.0)
• The system Tray icon for KeePassX and various other apps now appear correctly rather than being rendered as white squares, are no longer inappropriately scaled down in certain circumstances, and no longer crash Plasma in certain rare circumstances (Konrad Materka, Plasma 5.17.1)
• When discover is being used for offline updates and an update operation fails, it now offers to repair the system (Aleix Pol Gonzalez, Plasma 5.18.0)
• Full Screen windows are no longer inappropriately movable or resizable on X11 or Wayland (Marco Martin, Plasma 5.18.0)
• The System Settings Baloo file search page has been rewritten to have a shiny new QML-based user interface, which for now looks nearly identical to the old one, but provides a good base for fixing bugs and implementing new features (Tomaz Canabrava, Plasma 5.18.0)
• Kate’s editor color scheme chooser now works properly when used on a second High DPI display (Christoph Cullmann, Frameworks 5.64)
• Spectacle’s “Take a New Screenshot” button can once again be triggered with the Return or Enter key when focused (David Redondo, Spectacle 19.08.3)
• Dolphin no longer crashes when opened from the command line with a search schema (e.g. dolphin --new-window baloosearch://) (Ismael Asensio, Dolphin 19.08.3)
• Dolphin’s Information Panel no longer includes hidden files in the file count unless hidden files are visible (Méven Car, Dolphin 19.12.0)
• When adding multiple albums to the playlist in Elisa no longer results in their songs being added in mixed-up order (Matthieu Gallien, Elisa 19.12.0)
• K3B addons are once again listed in Discover (Aleix Pol Gonzalez, K3B 19.12.0)

User Interface Improvements

• Discover’s Installed apps list is now sorted by name (Aleix Pol Gonzalez, Plasma 5.17.0)
• The Plasma Audio Volume applet and its System Settings page now have a more streamlines and less redundant display style, and look much more similar to one another (me: Nate Graham and Sefa Eyeoglu, Plasma 5.18.0):
  
• Konsole’s “Are you sure you want to close these tabs” dialog can now be made to never again appear (Kurt Hindenburg, Konsole 19.12.0)

How You Can Help

Check out https://community.kde.org/Get_Involved and find out ways to help be a part of something that really matters. You don’t have to already be a programmer. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.