We’re delighted to announce the first maintenance release of the 24.02 series, tackling regressions, bugs, and crashes. A big thank you to everyone who reported issues during this transition – keep up the great work!
When file fails to open, display MLT’s warning to help debugging. Commit.
Fix crash trying to recover a backup after opening a corrupted file. Commit.
Fix multiple subtitles issues: several tracks not correctly saved, sequence copy not suplicating subs, crash on adding new subtitle track. Commit. Fixes bug #482434.
There are not a lot of changes in this release as the focus was on porting to Qt6 and KF6 and code refactoring.
Some hwdec options have been removed, if needed they can be set in the settings under "Custom commands" as set hwdec decoding_method_name and choose "Run at startup".
You can get it now on flathub:
Windows version can be found here.
Availability of other package formats depends on your distro and the people who package Haruna.
Feature requests and bugs should be posted on bugs.kde.org, but for bugs make sure to fill in the template and provide as much information as possible.
Changelog:
1.0.2
Features:
Opening items from the playlist is faster
If Maximum recent files setting is set to zero the recent files are removed from the config file
Bugfixes:
Opening file through Open File action was not playing the file
Opening playlist file from playlist header was not doing anything
Hiding/showing Playlist toolbar setting was not working
Track sub-menus in Audio and Subtiles global menus being empty
This is a piece I also wrote for the enioka blog, so there is a French version available.
At enioka Haute Couture we started offering trainings a little while ago.
True to our DNA this is focusing on software engineering practice rather than
a given tool, framework or API. This is why we have courses on topics like software
architecture, refactoring, dealing with legacy code, test driven development (TDD),
code review and so on.
Also, not every team has the same needs. Some prefer a few intensive days during a
given week, others prefer smaller sessions over an extended period. That’s why our
courses are designed to be flexible. They can be tailored to build a multi-day
session, or all the way down to many one hour knowledge building sessions.
Hopefully, this all sound great to you (for sure it does sound great to me). So why
talk about this now? Is it some kind of advertisement stunt? Well… not really.
You see, while working on our training offers something happened. Almost three years
ago GitHub announced GitHub Copilot. It was just a technical preview at the time.
Since then, there has been an arms race in the large language model (LLM) domain.
Like it or not, generative AI is here to stay and code assistants based on such
models are used more and more.
I’m not one of those doom sayers claiming such models and assistants are going
to take over our jobs. Likewise, I don’t think they’re going to double the
daily productvity of developers. Still, they will necessarily impact how we work
and the code which is produced. So keeping an eye on development practices, I’m less
concerned about disappearing developer jobs and more concerned about a drop in
the quality of the code produced.
Indeed, early studies indicate that code assistants when introduced in an
unchecked manner tend to push the code quality down and tend to increase
the amount of security issues introduced. Interestingly the main factors
highlighted are behaviorial. Which means that before waiting for a magical new
assistant which would code perfectly (spoiler: it won’t happen), we should rather
improve the way we introduce and use those tools.
Which gets me back to the [enioka Haute Couture trainings]. In this new era,
we have to acknowledge coding assistants during our trainings. This perfuses all the
topics I mentioned previously. There is now a nagging question for all our software
development practices: when is a coding assistant the right tool for the job?
If you’re practicing TDD or trying to improve your use of it, is it a good
idea to have the coding assistant write the tests for you? Maybe not… since it is
where you make important design decisions, you likely want to stay at the helm.
Might come in handy to generate the code which must pass the tests though.
If you’re dealing with a legacy code base which needs to be modernized, for which
part of the process the coding assistant will make you faster? Updating the code
to a newer version of the language or dependencies? Extracting clearer modules
and functions? Writing approval tests to secure all of that?
There are many more such questions… and you can explore the answers with us
during one of our training sessions. We’ll keep talking TDD, legacy code…
with a twist!
And of course, just like any other tools, what we’re proposing is not specific to
a given solution. You use GitHub Copilot? Codeium? A specific in-house fine-tuned
model? This is fine. We’ll take this into account during the training to adapt
it as much as possible to the involved developers and their context.
With KDE’s 6th Mega Release finally out the door, let’s reflect on the outgoing Plasma 5 that has served us well over the years. Can you believe it has been almost ten years since Plasma 5.0 was released? Join me on a trip down memory lane and let me tell you how it all began. This coincidentally continues pretty much where my previous retrospective blog post concluded.
The earliest clean full-desktop Plasma 5 screenshot I could find in my archives, dated December 2014
We released Plasma 5.0 on Tuesday, 15th July 2014, one week after the first issue of the KDE Frameworks 5, and 11 months after last Plasma 4 feature release which was part of the KDE Software Compilation 4.11. It featured an all-new shell written in QML and Qt Quick with infrastructure to switch between different form factors at runtime – ever wondered why the file it stores your desktop config in is called plasma-org.kde.plasma.desktop-appletsrc? It’s because your settings are stored per form factor.
Plasma 5 also came with a new theme titled “Breeze” with a frosted glass effect behind its panels and popups as opposed to the blurred transparency of its predecessor “Air”. This was done to avoid contrast issues with text on some, particularly dark, backgrounds. The unified System Tray popup that we still use today also had its debut then. Additionally, the window switcher, activity switcher, and widget explorer were all moved to a vertical sidebar on the left hand side to accommodate the now ubiquitous wide-screen monitors, a decision that was later criticized and ultimately let us choose a more traditional window grid again for Plasma 6’s Alt+Tab feature.
Unified System Tray popup, a staple of every Plasma desktop since 5.0
Neither the Breeze icon theme nor the Breeze window decoration were fully finished in time for the release, which meant that apart from the Plasma shell, visually the experience was very similar to using the KDE Software Compilation 4. Above all due to the fact that it wasn’t until December that we shipped our first KDE Applications based on Frameworks 5.
While there already was a Breeze window decoration featuring the meanwhile abandoned dark title bar and circle close button, it was built using Aurorae, the QML window decoration engine. Unfortunately, its new hardware-accelerated Qt Quick Scene Graph in Qt 5 didn’t interface well with KWin’s own rendering pipeline yet. Instead, a new KDecoration2 library was created to shed its predecessor’s dependency on X11 and Qt Widgets. However, the initial commit didn’t even land in KDE Git repositories until 18th July, three days after the release of 5.0.
You ain’t working hard enough if your desktop isn’t cluttered with sticky notes!
Unlike Plasma 6 which is obviously already built around Qt Quick and thus porting widgets was relatively straightforward, for Plasma 5 we actually had to rewrite them all. Only a few had previously been ported to QML in the late 4.x era, like the battery monitor, task manager, or virtual desktop pager. This meant that Plasma 5.0 featured a greatly reduced set of widgets, notably lacking most of the KDE Plasma Add-ons. Aside from that, in preparation for Plasma on Wayland, KWin’s binary was renamed kwin_x11 but kwin_wayland would only follow a few months later.
Plasma 5.1, published in October 2014 marked the return of the Sticky Notes widget as well as a few other omissions from the initial release. It also introduced the Clipboard applet in System Tray, replacing the QtWidget-based Klipper of Plasma 4. Alongside the re-introduction of the “Icon Tasks Manager” that behaves more like a Dock, mixing launchers, windows, and applications, it also saw the implementation of the “Alternatives” feature for quickly switching between similar widgets, such as regular task bar and icon task bar, or between different application launchers or clock styles.
We sure have come a long way in terms of UI design… (admittedly, Qt didn’t have great high-dpi support back then)
Speaking of clocks, I ported the most important of them all: Fuzzy Clock. Originally, it used JavaScript in the translation file (!) to transform “half past 8” to “halb 9” in German. I couldn’t figure out how to replicate that from QML since it didn’t know what to do with a KLocalizedString instance. Hence, I wrote a PHP script (it’s all the scripting languages I knew at the time) to generate the Array of 5-minute interval strings you still see in there today – true meta-programming! Finally, the Breeze widget style was now available for Qt 4 applications, making sure that visually both old and new looked indistinguishable.
Plasma 5 goes mainstream
The first release that saw widespread adoption was Plasma 5.2, released on 27th January 2015 and oh boy was that a psychedelic wallpaper! KScreen saw its return with automatic display configuration and remembering screen layouts based on the connected devices. Early Plasma 5 nevertheless had a couple of multi-monitor issues. This was also in part part due to bugs in then-new QScreen that we used instead of Plasma 4’s own Kephal library since we wanted to have a single source of truth for output configuration. I remember a colleague at work trying out Plasma 5.2 on Kubuntu 15.04 on his shiny new Dell laptop with high-dpi screen and was not very satisfied with the setup on his external 24″ monitor. To be fair, most of his issues were actually related to X11 not supporting per-display scaling.
Remember the Dashboard? Originally, there was another layer to place your widgets
Plasma 5.2 furthermore introduced the “Undo” feature when removing a Plasmoid. Shortly afterwards I assumed maintainership of PowerDevil, KDE’s power management service, and set up this very blog instance. In March 2015 I attended my first Plasma sprint in the Blue Systems Barcelona offices. It’s when we persuaded Ken Vermette (who even brought a French press in his suitcase all the way from Canada) to ship the wallpaper he had been using on his laptop as the default in Plasma 5.3, something he continued doing for many years, leaving a lasting impression on Plasma 5’s visual identity. It was also the inception of the Energy Info module, the first KCM (“KDE Configuration Module”) written in QML, and it unfortunately shows. The code hasn’t changed much since then, including its custom Canvas-based graph as we didn’t have a good QtQuick-compatible chart plotting library yet. The “wake-ups” API in UPower is long gone, however, and it’s definitely one of the user interfaces that in hindsight I am a lot less proud to still see around.
Amusingly, this file was named sexystats.png – not so sure about that ;-)
DDC (Display Data Channel) support in PowerDevil to control desktop monitor brightness is something I worked on at the time but it took many years (and in fact someone else to implement it) before it got actually shipped with Plasma. So much for “I’m quite confident to get that into 5.3.”. We might finally see multi-monitor brightness controls in a subsequent Plasma 6 update, though with HDR support many aspects of that need to be entirely reworked. A project I started that year which didn’t make it either is KDE Connect integration in Solid, KDE’s Hardware abstraction framework. The idea was to show devices paired through KDE Connect as removable storage just as any local USB stick would.
One year later
Plasma 5.4, released in August 2015, just after that year’s Akademy saw the return of KRunner’s history. David Faure told me at the conference he couldn’t switch to Plasma 5 without it, so here we are. This release was also the first to integrate with Qt’s relatively new high-dpi support and gave us a properly scaled user interface for applications, including spacing and line art, rather than just enlarged font sizes and icons. Plasma 5 from its inception was designed with high-dpi in mind and had its own scaling mechanism which predated Qt’s. It took us a long time to make the two work well together and only in Plasma 6 we were confident enough to make the Plasma shell scale its UI entirely using Qt’s mechanism by default under X11.
Dolphin in high-dpi Breeze glory for the very first time
Additionally, the Volume Plasmoid designed around PulseAudio (plasma-pa) replaced KMix. The full-screen application dashboard useful for convertibles and touchscreen laptops had its debut. And let’s not forget: Plasma Mobile was introduced in 2015, too! Seeing the volume popup I know from my laptop plop up on one of the Nexus 5 devices as I pressed the volume rocker was truly mind-blowing. People argued the purpose of Plasma Mobile a lot but thanks to Plasma’s modular nature much of its code was shared with its desktop counterpart. Also, much of the initial advances of Plasma on Wayland were driven by it since you really don’t want to have an X Server running on your phone. Some long-time KDE fellows might be able to tell you stories of a company that actually tried…
User switcher Plasmoid
One of my clients at the time was running Plasma 4 on a single shared computer they used for accounting and purchase. For ease of operation (they’re not computer-savvy people after all) I had installed the Fast User Switch Plasmoid. When it came time to migrate them over to Plasma 5, I naturally needed a replacement. Therefore, I wrote a clone of said applet in QML and upstreamed it to KDE Plasma Add-ons where it was released as part of Plasma 5.5 in December 2015. During its development I wrote a SessionsModel class for conveniently enumerating all logged-in users. Utilizing it, I created a proper user switcher for Plasma (nowadays we merely jump to the user switcher we already have on the lock screen), mimicking the look of the logout screen. This change actually made it into a printed issue of Linux Magazin! Previously, KRunner was in charge of that, a rather odd UI choice, I think. Fun fact: you can still type “SESSIONS” (all-caps) into KRunner today to bring up the list of logged in users.
Originally, we considered XEmbed, a protocol to embed X11 windows into other windows used for System Tray icons back in the days, obsolete. Nevertheless, we received many requests to restore support for legacy tray icons. That is why we came up with “XEmbed SNI Proxy” which acts as an XEmbed endpoint for apps to enroll their tray window with and translate them into proper icons registered with the contemporary Status Notifier Item DBus specification.
Plasma 5.5 is also when we started doing releases Fibonacci-style with the first update after a feature release scheduled just one week later, then another week, then two weeks, three weeks, and finally five weeks, just before the next feature release. This ensures that fixes for issues found in one of the new features reach users promptly. We’ll continue doing that for early Plasma 6, particularly for important additions to the Wayland session, but eventually we might consider slowing down a bit to take pressure of distributions having to package it all.
Jump list galore
Unity Launcher API in action (number badge and progress reporting) – also mind everyone’s favorite cashew!
I’ve always been jealous of Windows 7’s ability to display application progress, quick launch shortcuts, and recent documents in its task bar. I spent most of my Christmas vacation in 2015 implementing the so-called “Jump Lists” in Task Manager. Ubuntu’s then-current Unity desktop already implemented a DBus API for application badges and progress reporting that was already widely supported in non-KDE applications through libunity. Alas, I never wrote a KDE Frameworks equivalent, so the few KDE applications that make use of it (e.g. KDevelop for displaying compilation progress in task bar, or various chat applications indicating unread messages) just emit the relevant DBus signals directly. Only in Qt 6.5 did we finally get QGuiApplication::setBadgeNumber as a partial cross-platform replacement for the discontinued QWinTaskbarButton.
On top of that, applications can define additional actions in their desktop file that are listed in the relevant launcher context menu – be it pinned applications in task manager or the Kickoff menu. Notable examples are “Open new incognito tab” for a browser, or “Compose new message” for a mail client. Around the same timeSpectacle, our handy screenshot tool, saw the light of day, replacing KSnapshot, and of course I added a bunch of shortcuts for its various modes (such as “Take Rectangular Region Screenshot”), even though I usually just hit Meta+Shift+PrtScr (or Meta+R in Plasma 6 but that’ll always be “Run Command” to me) to take a region screenshot
Never implemented due to the kernel just side-stepping us here: Feedback OSD when toggling Wifi via keyboard shortcut
Plasma 5.6, released in March 2016 had the first release announcement to feature an introduction video with a narrator and all. It also enabled the Breeze Plasma theme to follow the current color scheme – there’s nothing like a Honeycomb Kickoff to brighten up your day! One thing we naturally don’t want to talk about is application crashes, which is why it’s not mentioned in the announcement that starting in this version DrKonqi, our crash handler, shows a sleek Plasma notification instead of its main window. The idea is to get you to re-launch your app as fast as possible and not add insult to injury by having you also close a stupid dialog window on the way.
Getting Physical @ CERN
One of my personal KDE career highlights was the 2016 Plasma Sprint at CERN (yes, the one with the particle accelerator) near Geneva, Switzerland. The event took place in their IdeaSquare, a place to collaborate and innovate within CERN, including a red ex-London double-decker bus parked in the middle of the building as a retreat, should you need to think about things in silence. It’s also when I tried to log into a Plasma Wayland session for the very first time.
Since Switzerland, and Geneva in particular, is quite expensive, for dinner we usually walked the 3km or so to neighboring village of Saint-Genis-Pouilly in France trying to find some more affordable restaurant options. As I came to the event by car, we also used it to buy cheap(er) beer in a French grocery store and sneakily drank it in the CERN cafeteria until they kicked us out at night. I sadly missed the tour of the particle accelerator (they also used Plasma 4 in their control room from what I heard) as I had already arranged to go skiing the adjacent weekend over in Austria.
Plasma 5.7, released in July 2016 made Jump Lists available through KRunner, too. We also came up with a way to colorize Breeze icons at runtime, replacing its dark strokes with white ones for use in dark themes as well as when used on top of the blue menu highlight. It’s done by merely altering the SVG string at load time, replacing a bunch of CSS rules. I hope with Qt’s renewed interest in icon theming we’ll get that functionality into Qt eventually. We also introduced the modular libtaskmanager with support for Wayland windows. It essentially does “functional programming” through QAbstractItemModel, stacking a bunch of proxy models on top of each other, each one executing a specific transformation (group by application, filter by desktop, etc) on the list of windows. Sadly, it lost the Win32 EnumWindows functionality in the process – yes, Plasma could display your Windows windows at some point!
Randaaaa, Valais, Switzerland – most beautiful village to host a developer sprint
In June 2016 I went to Randa Meetings in the Swiss Alps, one of the most productive sprints I’ve ever attended. Admittedly, there wasn’t much to do besides hacking all day and eating Swiss Chocolate. If you ever wondered whose finger it is pointing at me on my Phabricator profile picture: it’s David Edmundson’s. We had a bit of white wine that evening and while listening to music together decided it was a good idea to take random profile pictures. During our stay we also visited the village of Zermatt near infamous Matterhorn, a place devoid of cars! The only vehicles you’ll find there are small golf cart like electric vehicles to transport people and goods to one of the many hotels. It’s also where I had the most expensive scoop of vanilla ice-cream in my life. We also took the cable car up a mountain (which wasn’t Matterhorn but I can’t remember which one it was) and hiked back down, all the while talking about the then-new Qt 5.7 release.
KDE turns 20
I still fondly remember the first week of September 2016 when Akademy was co-hosted with Qt Con in Berlin. A bunch of KDE folks and I shared an apartment in Friedrichshain and the weather was just beautiful. Every morning we cycled from our apartment through Brandenburger Tor, past Siegessäule, to TU Berlin “MAR Building” where the BoF sessions were located.
Better use protective eye wear
Plasma 5.8, released in October 2016, just before KDE’s 20th birthday, is when we became really confident in Plasma 5 as a product and made it our first LTS (long-term support) release. Originally, we also considered Plasma 5.6 for that. It was also coming together nicely with Qt 5.6 declared an LTS release. To celebrate the occasion, we even got Chris Fisher of The Linux Action Show to voice our release announcement video! It’s also when we tried to unify the whole startup and shutdown experience and brought you the Blinding Blue colored login screen. Sorry about that! Actually, I had one of my office walls painted that color and I love it.
Typically, the first feature update after an LTS is the time to add fancy new features. Plasma 5.9, released in January 2017, sees two of the features I am still most proud of and enjoy every single day when using Plasma: audio indicators in task bar and draggable notification thumbnails. Being able to press a shortcut, take a screenshot, and then drag it from the preview in the notification popup straight to where I need it, the web browser, an email composer, or a chat client, is an unbelievable productivity booster.
Furthermore, web browsers back then already indicated which tab was playing audio, therefore it felt natural to have Plasma’s task manager do the same. Unfortunately, the audio stream isn’t actually attached to a window, thus every window of the same app will show the indicator. While PulseAudio actually supports apps associating their audio stream with an X11 window ID, I have never seen this actually used in practice and of course that wouldn’t help us much under Wayland. It gets even more complicated when you consider sandboxing (where the process ID a client reports might be in a different namespace from the Plasma shell) or a web browser’s multi-process architecture (where the process owning the window is not necessarily the one managing audio streams).
Plasma Sprint in Stuttgart
Last time I checked the KDE decoration they put up for us was still there
In 2017 I organized the Plasma Sprint in Stuttgart, kindly hosted by my employer at the time. That’s when I unveiled Plasma Browser Integration, an extension for Firefox and Chrome to more tightly integrate them with the Plasma desktop. I realized that people spend most of their time on a computer actually on the web and with KDE not having a stake in any of the major browsers anymore it became virtually impossible to seamlessly bridge the two worlds. KDE Connect integration, finding browser tabs through KRunner, and download reporting in Plasma’s notification center were my main motivation for fathering this project.
Didn’t make the cut: Incognito tab indicator in Plasma Browser Integration
One night we went up the Fernsehturm (TV tower) in Stuttgart which had only recently reopened after renovation owing to fire safety regulations. I haven’t been up there there myself despite growing up in The Länd so I figured it’d be a nice social event. It’s that day when at 147 meters above the ground we brainstormed apps surviving a crash of the Wayland compositor for the very first time. Aside from that, during the sprint, some folks went to local Media Markt and bought a floppy drive. This allowed me to fix Solid erroneously calling them “0 Byte removable media”. It actually wasn’t until KDE Gear 23.08 of last year that KFloppy, a tool to format floppy disks, was finally allowed to retire.
That year is when we coined the expression “Simple by default, powerful when needed” that captures the spirit of Plasma very well. Out of the box, it just works for the majority of our users whereas it also lets them tailor it to their very specific needs. Back in the days, I had to spend forever wading through config dialogs before I was satisfied with the KDE desktop experience. Nowadays, I just move the panel to the top and window buttons to the left because I prefer it that way and call it a day.
Unresponsive apps get desaturated since Plasma 5.10
I didn’t attend Akademy 2017 in Almería for personal reasons. Nevertheless, I actually received an Akademy Award for my work on Plasma which is complementing the blue wall in my office very nicely. Due to my absence, I received it by mail alongside an Akademy T-Shirt. The yellow sun with KDE logo is still one of my favorite designs and I wear it a lot!
In 2018 I joined Blue Systems to work on KDE software full-time. Of course that meant that there’s now so many more things to talk about that it would surely go beyond the scope of this post, therefore I will wrap it up here since – as always – there has to be some material left for a sequel. I hope you enjoyed dwelling in the past with me for a while and it made you just as excited as I am about the next decade with Plasma 6. We undoubtedly wouldn’t be here without your continued generous donations, support, and contributions!
“Here’s to the next 10 years” (CC-BY-SA 4.0 Drakonic)
I mentioned recently that KDE Plasma 6 is available on FreeBSD – but not all of
the KDE Megarelease, and that Plasma 6 can’t co-install with Plasma 5
from the regular ports tree right now. Since we definitely want
testing, here’s a VirtualBox setup for it. (I still have not
spent the time figuring out bhyve locally)
The first line is the important one for the purpose of testing KDE Plasma 6, the second one
is to have a backup (X11) environment to test that things like
graphics work at all. Note that there is no display manager installed,
no greeter, so we’re going to fall back to the old-school way of
starting X11 sessions, after logging in as a regular user:
$ XINITRC=/usr/local/bin/twm startx
This starts ol’ reliable, on a fully black screen. Left-click to get
the twm menu, from which either Xterm or Exit are good choices.
Once we know X11 works at all in the VM, start a nicer desktop:
$ XINITRC=/usr/local/bin/startplasma-x11 startx
KDE Plasma 6 Desktop on FreeBSD
There we go, a very minimal KDE Plasma 6 on a FreeBSD machine.
There are some obvious things missing, like the icons for
the K-Launcher, for System Settings, and for Discover.
Now, discover isn’t even installed here (although I think it has
recently gained a FreeBSD package backend, so it could work).
This looks like an
assumption about system integrators with the default configuration.
Missing icons is either a question of paths being different, or
packaging not pulling in everything that is needed.
Keeping in mind that 800x600 is not at all the preferred resolution
for KDE Plasma 6 (but it is workable!), there’s some things
I immediately like about it: the floating panel works well and looks nice,
and the spinners for application launch are smooth.
So, well done Plasma devs, and Tobias for landing most of those bits.
For a while Qt has been offering qmlls, a Language Server Protocol implementation for QML. This allows popular text editors like Kate (and some lesser known ones like Visual Studio Code) to work with QML code without having to write dedicated support for it.
Naturally many people are eager to use it to hack on KDE code. When trying to do that you probably have encountered some frustration with things not working as expected. So what’s going on there, and how can we make it work?
First and foremost one must mention that qmlls is still under heavy development. There’s a number of things missing that you’d expect from a fully featured LSP implementation. If you encounter something that looks like it should work but doesn’t, don’t hesitate to file a bugreport.
So how does one use qmlls? In Kate it should be activated out-of-the-box when opening a QML file. If that doesn’t work you might need to tweak the LSP-Client settings. For other editor please consult their documentation on how to enable LSP support.
One problem you are likely to encounter when using qmlls on KDE code is that it fails to find KDE-provided QML modules like Kirigami. This happens when the modules are installed into e.g. ~/kde/usr, which isn’t searched by Qt. One way to get around this is to build and install your own Qt into ~/kde/usr too, since that way the modules will be installed into the same prefix as Qt and Qt will find them. While building your own Qt is a worthwile thing to do in general it’s not a very satisfying solution. I hope we can find a better solution for this soon. See here for a related bugreport.
If your installation is set up in a way that qmlls can find the KDE-provided modules you might still encounter it warning on unknown modules or types. In order for qmlls to show information for a module the module needs a qmltypes file. These files provide machine-readable information about the types that the module exposes. The easiest way to make these available is porting the module to ecm_add_qml_module and declarative type registration. This was done for many KDE modules already, but there’s still a number of them missing. Help on that is very welcome! Something that isn’t obvious is that in order for the tooling to work correctly module dependencies need to be marked explicity via the DEPENDENCIES parameter in ecm_add_qml_module.
If all the modules and types are found correctly you will still encounter some warnings, but most of these should correspond to actual issues and non-optimal practices like using unqualified property lookups and context properties. qmlls is a great tool to guide you towards resolving those and thus modernizing and optimizing the code. There are however some classes of warnings for which we don’t have proper solutions yet:
Our translation functions, i18n and friends, are considered unqualified lookups by qmllint/qmlls. This is because they are magically injected into the engine at runtime. It’s not clear how a solution for this could look like.
When writing KCMs we expose the module’s C++ class via the kcm context property, which is opaque to the tools. A different approach is needed.
Despite the current limitations qmlls is already a very useful tool for working on QML code, assuming the project is set up properly.
Happy QML hacking!
If you are reading this from the future there’s an update available.
KDE applications run everywhere. KDE Frameworks are useful across many different
operating systems – FreeBSD and OpenBSD
and all those Linuxen and Microsoft Windows and Apple MacOS.
That also means doing regular builds and testing (CI) for those operating systems.
Linux and FreeBSD CI happens on servers run by KDE e.V.
I’m not sure where the Windows CI happens. I do know where
MacOS CI happens, because it is in my utility closet at home.
MacOS CI is perhaps most important for Krita,
and I picked up the machine – an M1 Mac Mini – from Halla this week to give
it a more stable home with a UPS and all. But that means setting up a MacOS
machine in the utility closet.
Oh, man, the MacOS experience.
For me personally, coming from an almost-exclusively-KDE, 85% FreeBSD 10% Linux 5% Windows background,
“MacOS blows goats” is about as positive as I can phrase it.
So far during setup:
Your monitor displeases us. I was already told that the machine wouldn’t
start well without a monitor (unlike the rest of the world). My spare monitor,
the one for quick setups of arbitrary bits of hardware, was incompatible.
Only thing I can come up with is that a 10-year-old 720p TV is judged insufficient.
Your keyboard displeases us. Similarly, my spare Dell USB keyboard was problematic.
Plugging it in pops up a keyboard configuration dialog (unlike the rest of the world)
and in that dialog, pressing the wrong button will disable the keyboard entirely.
Your mouse is vaguely acceptable. The Trust wireless mouse is accepted immediately,
and except for the scroll wheel which matches touchpad directions (unlike the rest of the world),
I can click on things.
Yay, then I can click around to turn on the SSH server and other bits.
It will take a couple of days before the machine is fully up-and-running.
Partly that’s because every UI interaction I undertake is slllooooowwww
because of all the head-scratching, wtf-ing, and hair-pulling. Once I can
hand it off the KDE Sysadmin and can close the door of the closet,
I will be much happier – and KDE’s CI, too.
Definitely this. It might ultimately impact the abstraction levels accessible to us for coding… but the skills will still be needed. Natural language is too ambiguous for the task.
Indeed this. It’s not only about payload size, it’s also about CPU consumption. Our profession is still assuming too much that users will get faster CPU on a regular basis.
Interesting paper showing the main reasons why people ultimately change their phones. I find interesting that the opacity of storage management on mobile devices is such a factor.
Indeed, don’t mindlessly add tests. I find interesting that the doubts raised in this piece are once again concluded using an old quote of Kent Beck. What he was proposing was fine and then over time people became clearly unreasonable.
Very interesting piece. The DORA metrics are a good thing but I always felt they’re kind of dry and missing something. On the other hand surveys which are more qualitative give also interesting results but come with their own biases. The idea pushed here for better qualitative surveys and to combine them with quantitative metrics like the DORA one is definitely a tempting way forward.
ervin
@kbroulik:kde.org
colored login screen. Sorry about that! Actually, I had one of my office walls painted that color and I love it.
