You may have read about my new-found fondness for Plasma’s Clock app. Following the development of a “Picture in Picture” protocol for Wayland, I remembered how I once saw someone put up a little timer window during a lunch break while screen-sharing a presentation. I figured, I wanted that, too!

A key difference between X11 and Wayland is that Wayland is descriptive, not prescriptive. For example, a drop down menu under X11 is a window with no border that is placed in a very specific location determined by the application. It then grabs all the input so that up and down arrows work and clicking outside will dismiss it. That also means that global shortcuts won’t work while the menu is open. You can’t take a screenshot of it, you can’t even lock your screen. In 2025, this is embarrassing.

Under Wayland on the other hand, such a menu is an XDG Popup. The application tells the compositor what button it came from and what to do when it can’t fit (flip to the other side, scroll, etc). The compositor then gets to decide where to put the menu (not crossing display boundaries, for example) and to make sure it goes away when you click elsewhere or switch to a different application.

This also means that an application is a lot more restricted when it comes to – let’s say – creative window behavior. Take the picture-in-picture feature for example: an application can’t just decide to keep its window on top of everyone else. Normally, that’s a good thing! But it likewise prevents implementing a little overlay video player in your Web browser under Wayland. Enter xx-pip-v1.

It’s a protocol very similar to XDG Shell but instead of managing desktop-y windows and popups, it creates floating picture-in-picture windows. KWin recently gained support for it. As indicated by the “xx” prefix it’s an experimental protocol and therefore guarded by a KWIN_WAYLAND_SUPPORT_XX_PIP_V1 environment variable. As with most protocols, having a test case is nice but a proper application making use of it will uncover gaps and oversights in the protocol much better. Therefore, I took the opportunity to allow KClock to pop out timers and the stopwatch into a little PIP window.

While it can and does take time to sketch a Wayland protocol to realze a new use case, the end result will be generally better than anything we had before. Rather than an application deciding how PIP should behave, the compositor is in full control and subsequently you, the user. We could offer an option for which corner the window should be placed by default, or to not show it at all, and do it consistently for all applications.

Many thanks to Vlad Zahorodnii for his work on the xx-pip-v1 protocol and whose demo application the KClock implementation is based on and to David Edmundson for implementing window move/resize in the PIP window.

When we were at TU Graz for the KDE Plasma Sprint and Grazer Linuxtage a few weeks ago the question came up how to practically map such buildings in OpenStreetMap given their available floor plans. As I’m mostly involved in using rather than creating OSM data I didn’t have a good answer for that back then. Thanks to input during the following quarterly OSM Indoor Meetup, you’ll find some hints on approaches and tools below.

Indoor Mapping

Navigating in complex public buildings is a similar challenge than navigating outdoors, detailed map data is crucial in both cases. And while indoor mapping is a somewhat niche topic in OSM still, there’s applications such as Itinerary and Transitous making use of that for train stations or airports, and Kongress applying this in conference venues.

For displaying maps split up by floor level we already get somewhat usable results with partial information as humans are very good in filling in the blanks.

Routing algorithms however are very dumb and very clever at the same time, dumb when it comes to making “common sense” assumptions when facing missing information and clever when it comes to finding creative shortcuts by exploiting incomplete information. So completeness is important here.

And that’s even more the case when looking at accessibility usecases, no matter whether applying human or machine routing. Every single step somewhere can be a blocker for a wheelchair, and if you rely on tactile guides a mismatch between map and reality hurts a lot more than when you can fill the gaps by what you see on the spot.

Building plans

The hard part of mapping building interiors is usually to get the geometry of rooms, corridors, walls, etc. in correctly. Measuring this all by hand in reference to the outer structure is a very tedious job, tools commonly used for outdoor mapping such as GPS and geo-referenced aerial imagery wont help here.

There’s alternatives to this though:

• Importing from digital Building Information Models (BIM). While tools exists for this getting access to these extremely detailed engineering models is hard. A group from TU Munich is currently exploring this for importing about 400 building parts of their campuses.
• Images of to scale floor or evacuation plans are usually easier to obtain. Those generally cannot be imported automatically, but offer a similar help as aerial imagery for outdoor mapping. TU Graz has those available in their room information system in several variants and formats for example. We’ll focus on this below.

As always it’s important to make sure the material you use is available under a suitable license and/or there’s an explicit permission for use for OSM mapping.

Using building plans in JOSM

Setup

While the following assumes you have JOSM set up and connected to your OSM account, there’s additional plugins needed for this. Those can be installed via “Edit > Preferences… > Plugins”. The main one is “PicLayer”, “measurement” will also come in handy in many cases.

When using JOSM via Flatpak you’ll likely also want to give it full file system permissions for this. JOSM is based on Java Swing which has no support for XDG portals for accessing files. While that’s usually not an issue when editing OSM data it wont be able to open local build plan images otherwise.

Building outline

Editing a building starts with identifying the building outline. In practically all cases that will already exist in OSM, there might be cases with more than a single outline though, e.g. when a building has different extents on different floors.

Besides the building plan, aerial imagery available in JOSM can be a useful reference here.

In the above example we see that the existing outline covers the building extent at its top floor, omitting the parts on the ground floor towards lower right side as well as the small glass extension to the top.

That’s of course worth fixing on its own, and if the rooms you want to map are in that part of the building it’s the first step anyway. It’s yet another topic though, so for now we assume the part we want to map is covered by the existing outline.

Aligning the building plan

The next step is then to properly align the building plan image underneath the building outline, as that will most likely neither be scaled nor rotated correctly after adding it via “Imagery > New picture layer from file…”.

After enabling the building plan layer to be the currently active one (ie. it having the green checkmark in front of it in the “Layers” sidebar pane), controls for manually scaling and rotating become available. That works, but can be rather cumbersome to use.

Much more convenient is the automatic calibration feature of the PicLayer plugin. For this we need to know the physical length of two lines of the building outline. Whether that’s read from the building plan, measured in JOSM on the building outline or aerial imagery (which is where the measurement plugin comes handy), or measured in real life doesn’t really matter.

Calibration can then be started via “Mode > PicLayer auto calibration” in the menu (again, make sure the building plan layer is enabled), which gets you the following dialog.

Follow that from top to bottom:

• Select “Add points…” and click on three points on the building plan for which there are corresponding points in the building outline.
• The following two text input fields become enabled then, enter the physical length in meters between point 1 and 2 as well as 2 and 3.
• Click on the left “Select a layer including the building outline as reference…” and pick the OSM data layer in the follow dialog, by default that’s called “Data Layer 1”.
• Finally, select the “Add points…” action on the bottom, answer the following message box with “defined” (ie. we already have an existing building outline), and then pick the three OSM nodes corresponding to the points you selected on the building plan.

With all that done, the “Run” action becomes available and if everything matches this results in the floor plan being correctly position behind the building outline. The process can fail e.g. if the plan and the outline can’t be made to match, e.g. because the measured values were wrong or the selected points weren’t actually the same.

For more details also see the PicLayer documentation which has a step-by-step animation of this.

To avoid having to go through this process multiple times, there’s actions in the context menu of the image layer to save and restore the calibration data.

Mapping room geometry in JOSM

With the building plan correctly aligned we can start to add room geometry. As many buildings have predominantly rectangular structures, enabling “Edit > Angle Snapping” once in “Draw Mode” tends to be very helpful. That not only helps with producing 90° angles but it also provides guiding lines for aligning e.g. multiple walls on a straight line.

In most cases the so-called “thin wall” model is used, that is walls between rooms are mapped as a one-dimensional line rather than as two-dimensional geometry (“thick wall” model). Exceptions might be very old buildings with very thick or irregular walls such as castles or cathedrals. While (visual) renderers and routers would benefit from the higher level of detail of the “thick wall” model it poses a big challenge for tactile renderers as those can only output a much reduced information density and “pixel” resolution.

The bare minimum tagging on new geometry would need to be the level tag containing the floor level and the indoor tag describing the general type of structure (room, corridor or open area). There’s a lot more that could be added though (see below), but that is often better and easier to do on-site.

Don’t forget to also map corridors and open areas as well as possibly missing pieces of outside walls. Humans tend to automatically fill those in when looking at a map, but routers wont.

Mapping doors

Another thing that’s easiest to add from building plans are doors. Without those routers will steadfastly claim rooms are impossible to enter.

Doors are generally mapped as points. So that’s a matter of clicking on their center on the room geometry and tagging the resulting new node with indoor=door and the corresponding level as the bare minimum.

If a door is not meant to be used by the public, e.g. because it’s locked or because it’s an emergency exit, that’s also crucial to tag as routers will otherwise happily exploit this new shortcut. See access, entrance and exit for this.

Floor level changes

Structures that allows changing between floor levels (staircases, elevators, escalators, ramps, etc) are also essential to tag as such, with the important part being the level tag containing the set of floors reachable this way.

Without that routers wont find their way up or down a building.

And everything else

There is a whole lot more details that can be tagged on the new geometry then, such as:

• Room names (name) and numbers (ref).
• room semantics, e.g. lecture hall or a restroom.
• door width and opening properties, which can be quite relevant for wheelchair users. Similarly for stair and elevator properties.
• Toilet properties.
• Information about tactile_paving guides and handrails, which are useful for people with reduced vision.

Adding all those details is much closer to outdoor OSM mapping and can also be done e.g. with mobile editors. An editor that can do floor-level filtering is still useful, but you can get a long way there without touching geometry, making this also a much more approachable activity for new OSM contributors.

Interested in more?

For some inexplicable reason you find all this super exciting and want to get more involved? No problem, there’s plenty of opportunities:

• Join the quarterly online OSM Indoor Meetup.
• Join the next OSM Hack Weekend.
• Join the Transitous Hackweekend and/or the Open Transport Community Conference for the use of this around train stations.

Welcome to a new issue of This Week in Plasma!

Every week we cover the highlights of what’s happening in the world of KDE Plasma and its associated apps like Discover, System Monitor, and more.

This week we not only continued polishing up Plasma 6.4 in response to feedback (thanks to everyone who submitted bug reports and wrote nice emails to us), but we also started work on bigger improvements to Plasma 6.5.

Probably the biggest one is the next piece of the Wayland session restore puzzle clicking into place: David Edmundson has implemented support for the xx-session-management-v1 Wayland session restore protocol in Qt 6.10! This means that software built on top of Qt 6.10 (for example, Plasma and KDE apps) will be able to start implementing the protocol themselves. Once they do, then finally real session restore will work on Wayland. We're not all the way there yet, but we keep on working to get closer all the time!

But that’s not it! We’ve got a whole lot more, too…

Notable New Features

Plasma 6.5.0

Plasma’s Welcome Center apps now teaches you about the many keyboard shortcuts in Plasma, as well as what the heck the “Meta” key is. (Nate Graham, link)

Plasma’s built-in RDP server now supports syncing clipboard text between the client and server. (Arjen Hiemstra, link)

Notable UI Improvements

Plasma 6.4.1

The “Highlight windows” effect has been turned off by default on the Task Manager widget, for accessibility reasons discussed in more detail a few days ago. (Nate Graham, link)

Refined the tone mapping feature in KWin to improve the look of some screen content when using HDR or EDR. (Xaver Hugl, link)

You can no longer open an infinite number of error messages in Spectacle’s UI by repeatedly doing a thing that triggers them, and then not stopping even though maybe you should. (Noah Davis, link)

Plasma 6.4.2

Spectacle no longer includes a ghostly semi-transparent version of its own menus in screenshots taken within the app when not using any kind of delay. (Ismael Asensio, link)

The “New!” badges applied to newly-installed apps shown in the Kickoff Application Launcher are now more appealing and easier to read by using semantically correct colors from the active color scheme. (Kai Uwe Broulik, link 1 and link 2)

In the Kicker Application Menu widget, you can now activate the power/session actions using the Enter key, in addition to the Space key. Now all the UI elements on that widget can be activated with Enter. (Christoph Wolk, link)

Made the Night Light feature’s color tinting look nicer on certain hardware. (Xaver Hugl, link)

Plasma 6.5.0

The notification telling you that you missed some notifications while you were in Do Not Disturb mode now includes a button you can click on to actually see those missed notifications! (Kristen McWilliam, link)

You can now copy the QR code for clipboard items, in addition to just being able to look at them and scan them. (Ismael Asensio, link)

The “Click here to change the icon” button that’s visible on the Properties window and other QtWidgets-based apps is now more obvious as to what its purpose is. (Kai Uwe Broulik, link 1 and link 2)

The Networks widget now tells you what what it’s doing for more more potential states that it can be in, including “looking for wireless networks” and “uh, I’ve been disabled, dude.” (Nate Graham, link)

System Settings’ Printers page also now gives you a better error message if its service has been disabled. (Mike Noe, link)

On System Settings’ Region & Language page, the error message that tells you language packages couldn’t be installed now actually mentions their names so you can try to troubleshoot it a bit. (Ismael Asensio, link)

Frameworks 6.16

All scrollable views in all QtQuick-based KDE software now have inertial scrolling when scrolled using a touchpad! Note: only with a touchpad, not with a mouse wheel. No inertia there. Say it with me: no inertia for mouse wheels! (Niccolò Venerandi, link)

Improved the accessibility of the common Properties dialog in many ways. (Felix Ernst, link 1 and link 2)

Notable Bug Fixes

Plasma 6.3.6

Made the Environment Canada provider for Plasma’s Weather Report widget work again after they changed the data format. (Ismael Asensio, link)

Plasma 6.4.1

Fixed several crashes in in KDE’s desktop portal implementations. (David Redondo, link 1 and link 2)

If you have a Samsung Odyssey G5 monitor, it no longer turns on and off forever while Powerdevil’s DDC support is enabled, because the monitor’s own DDC implementation is completely broken, so we blacklisted it. (Xaver Hugl, link)

Fixed an accessibility regression that caused the Install and Remove buttons on Discover’s app pages to be excluded from the tab focus chain. (Christoph Wolk, link)

Deleting a file or app that’s been made a favorite in Kicker/Kickoff/etc no longer makes it impossible to un-favorite that thing. (Christoph Wolk, link)

Fixed an issue in the Window List widget that prevented it from being able to minimize or maximize windows. (Christoph Wolk, link)

Fixed an issue in KDE’s desktop portal-based open/save dialog that caused extra UI elements added by apps to appear in the wrong places. (David Redondo, link)

Fixed an issue with the new “relative mode” for drawing tablet styluses that could cause the pointer to disappear when you have two tablets connected at the same time and each of them uses a different input mode. (Vlad Zahorodnii, link)

Fixed two visual glitches that could be caused by re-arranging virtual desktops in the Overview effect’s grid view. (Vlad Zahorodnii, link 1 and link 2)

Fixed an issue that made clicking on Plasma UI elements unreliable when using certain non-default click modes. (Vlad Zahorodnii, link)

Plasma 6.4.2

Fixed a case where System Settings’ Flatpak App Permissions page could cause the whole app to crash (Daniel Hast, link)

Fixed an issue that could sometimes cause Plasma to go back to sleep again right after waking up, when the “Sleep then hibernate” setting is in use. (Myrrh Periwinkle, link)

The appearance of text labels in Folder View pop-ups is once again correct. (Nate Graham, link 1 and link 2)

You’re no longer erroneously prompted to authenticate for a Wireguard VPN whose credentials are already stored in KWallet, and the wallet is set up to automatically open at login. (Jeff Chien, link)

Fixed an issue in the KDE desktop portal’s screenshot implementation that prevented the delay setting from taking effect. (David Redondo, link)

Missing app backends listed in Discover’s Settings page once again show the correct names. (Harald Sitter, link)

The brightness level shown on System Settings’ Display & Monitor page now matches the one shown in Plasma. (Xaver Hugl, link)

Fixed an issue that caused the panel to have too much space in it until restarting Plasma if you stop displaying the date on a horizontally-laid-out Digital Clock widget. (Niccolò Venerandi, link)

Qt 6.8.4

Fixed a Qt bug that caused is to be extremely frustrating to re-arrange Task Manager icons because the drag target would change after you dragged an icon over another one. (Niccolò Venerandi, link)

Other bug information of note:

• 4 very high priority Plasma bugs (up from 3 as last week). Current list of bugs
• 28 15-minute Plasma bugs (up from 26 last week). Current list of bugs

Notable in Performance & Technical

Plasma 6.3.6

Fixed an issue that could cause stuttering when playing video content in certain video players when using a variable-refresh-rate screen. (Błażej Szczygieł, link)

Plasma 6.4.1

Fixed a recent performance regression with certain games. (Vlad Zahorodnii, link)

Plasma 6.5.0

Increased the perceived responsiveness of logging into Plasma by optimizing the splash screen code and re-arranging some of the startup steps. (Vlad Zahorodnii, link 1 and link 2)

Slightly reduced the duration of the login animation, which makes logging into Plasma feel a bit snappier. (Vlad Zahorodnii, link)

How You Can Help

KDE has become important in the world, and your time and contributions have helped us get there. As we grow, we need your support to keep KDE sustainable.

You can help KDE by becoming an active community member and getting involved somehow. Each contributor makes a huge difference in KDE — you are not a number or a cog in a machine!

You don’t have to be a programmer, either. Many other opportunities exist:

• Triage and confirm bug reports, maybe even identify their root cause
• Contribute designs for wallpapers, icons, and app interfaces
• Design and maintain websites
• Translate user interface text items into your own language
• Promote KDE in your local community
• …And a ton more things!

You can also help us by making a donation! Any monetary contribution — however small — will help us cover operational costs, salaries, travel expenses for contributors, and in general just keep KDE bringing Free Software to the world.

To get a new Plasma feature or a bugfix mentioned here, feel free to push a commit to the relevant merge request on invent.kde.org.

Dear readers,

Before our regularly scheduled program, it is time for a little service announcement.

I will be taking some vacations for the coming three weeks. I’ll try to disconnect as much as possible for once. I thus won’t post another review in the next three weeks. It also means that I’ll try to not read as much as usual on the web either, so I probably won’t collect many URLs during that period. Don’t expect a mega-compilation when I come back!

That being said, let’s go for my web review for the week 2025-26.

Everyone should copy Thunderbird

Tags: tech, foss, fundraising

This is a model which seems to work for donation campaigns for FOSS projects. I wonder how much this scales though… if everyone does that, is there a point where users will be fed up with it?

https://blog.cyrneko.eu/everyone-should-copy-thunderbird

Matrix.org - Dispelling myths and misinformation

Tags: tech, matrix, community, foss

It’s indeed difficult to separate FUD from the real community issues around Matrix right now. We’ll have to keep an eye on how things evolve.

https://matrix.org/blog/2025/06/dispelling-myths/

A family of forks

Tags: tech, ssl, security, foss

The situation around OpenSSL and its fork is rather confusing… And there’s no indication this would improve.

https://daniel.haxx.se/blog/2025/06/23/a-family-of-forks/

Are LLMs ‘useful’?

Tags: tech, ai, machine-learning, gpt, criticism

Interesting comparison, indeed would a clock like this be useful?

https://azhdarchid.com/are-llms-useful/

Why computational reproducibility matters

Tags: tech, reproducibility, science, research

There are indeed fields where this matters a lot. It is far from being an easy problem to solve though.

https://blog.khinsen.net/posts/2025/06/20/computational-reproducibility.html

Introduction to the A* Algorithm

Tags: tech, algorithm, graph

Nice explanation of how graph search algorithms work. If you need to build some path finding feature this is for you.

https://www.redblobgames.com/pathfinding/a-star/introduction.html

Deep Down the Rabbit Hole: Bash, OverlayFS, and a 30-Year-Old Surprise

Tags: tech, linux, kernel, system, filesystem, shell, debugging

You like weird bugs involving shell implementations, syscalls and filesystems? Somehow I do, this was an interesting one.

https://sigma-star.at/blog/2025/06/deep-down-the-rabbit-hole-bash-overlayfs-and-a-30-year-old-surprise/

mbake is a Makefile formatter and linter. It only took 50 years!

Tags: tech, make, linting, tools

Nice! At last a Makefile linter. It has some interesting features, I especially like the automated .PHONY target management.

https://github.com/EbodShojaei/bake

Fun with uv and PEP 723

Tags: tech, python, scripting

uv really opens the door to nice features for Python. Now with a standardized PEP to help the configuration it’s getting even better.

https://www.cottongeeks.com/articles/2025-06-24-fun-with-uv-and-pep-723

Basic facts about GPUs

Tags: tech, gpu, computation, hardware, performance

A good reminder that “push it to the GPU and it’ll be faster” isn’t true. If you move a workload to the GPU you likely have to rethink quite a bit how it’s done.

https://damek.github.io/random/basic-facts-about-gpus/

Passing Functions to Other Functions in C++

Tags: tech, programming, metaprogramming, c++

A bit old perhaps, but shows quite well the various options to pass a function around in C++.

https://vittorioromeo.info/index/blog/passing_functions_to_functions.html

std::shared_ptr’s secret constructor

Tags: tech, c++, memory

I think this is indeed something still easily overlooked. You can deal with this kind of intertwined lifetime issues using shared_ptr.

https://www.justsoftwaresolutions.co.uk/cplusplus/shared-ptr-secret-constructor.html

Reflecting JSON into C++ Objects

Tags: tech, c++, metaprogramming

More details one how the new C++ reflection features can be used. This is a really nice feat here to parse a JSON at compile time to make an object.

https://brevzin.github.io/c++/2025/06/26/json-reflection/

Weird expressions in rust

Tags: tech, rust, type-systems, funny

I like this kind of oddities in languages. This is nice to see such a list for Rust at a single place.

https://www.wakunguma.com/blog/rust-weird-expr

“Why is the Rust compiler so slow?”

Tags: tech, rust, compiler, performance

Nice exploration which shows the many levers one can use to impact Rust compilation times. They all have their own tradeoffs of course, so don’t use this just for the sake of reducing time.

https://sharnoff.io/blog/why-rust-compiler-slow#putting-it-together

How much code does that proc macro generate?

Tags: tech, rust, metaprogramming, compiler, performance

Nice new tool to investigate code generated by macros in Rust. Indeed you can quickly add lots of lines to the compiled code without even realizing, in large code bases it’s worth keeping in check.

https://nnethercote.github.io/2025/06/26/how-much-code-does-that-proc-macro-generate.html

Rust: A programming language that grows with you, your career and your projects

Tags: tech, rust, learning, expertise

This piece is a bit too much written as Rust zealotry for my taste. That being said, there’s in my opinion an interesting core truth hidden in there: for now it seems to better foster “expert generalists” when investing in it. Now it might be just for now and might stop later… time will tell.

https://kerkour.com/rust-grows-with-you

No Time To Learn (Web) Framework X

Tags: tech, web, framework, learning, career

Good followup to a similar piece from someone else about React. Frameworks with a short half-life are not worth the hassle to learn, focus on more fundamental skills instead.

https://brainbaking.com/post/2025/06/no-time-to-learn-web-framework-x/

Classes vs. Data Structures

Tags: tech, programming, type-systems, object-oriented

This is a difference which needs to be reminded. Using precise language obviously helps.

https://blog.cleancoder.com/uncle-bob/2019/06/16/ObjectsAndDataStructures.html

TDD Antipatterns

Tags: tech, tdd, tests, pattern

Yes, tests can follow patterns as well… and antipatterns too. It’s good to name those antipatterns, let’s avoid them shall we?

https://agileinaflash.blogspot.com/2009/06/tdd-antipatterns.html

Pairing vs. Code Review: Comparing Developer Cultures

Tags: tech, quality, pairing, codereview, culture, team

Both approaches have their pros and cons of course. Whatever you pick, it has to start with a care for quality shared within the team.

https://phinze.com/writing/pairing-vs-code-review

Don’t get locked up into avoiding lock-in

Tags: tech, foss, vendor-lockin

Interesting framework to reason about lock-ins. It’s not only about depending on a vendor, there are other factors to keep in mind. Now obviously I’d see the risks around cloud hosting in particular in a different way than the author… but I guess we’re biased differently there.

https://martinfowler.com/articles/oss-lockin.html

In Praise of “Normal” Engineers

Tags: tech, productivity, organization, team, engineering, culture

I like this article. Indeed, focus on building organisations and teams where it’s easy to do the right thing bit hard to fail. This is much better than obsessing over mythical 10x engineers.

https://charity.wtf/2025/06/19/in-praise-of-normal-engineers/

The Case for Scrum Dying in a Fire

Tags: tech, scrum, agile, criticism

The whole Scrum training and certification industry has a problem… and it’s been going on for a long time.

https://ronjeffries.com/articles/2015-02-23-die-in-a-fire/

Ticket-Driven Development: The Fastest Way to Go Nowhere

Tags: tech, agile, project-management, craftsmanship, team

If your team is solely in “pushing tickets out” mode, there’s indeed a problem. Teams needs more agency and care for the output to actually strive long term.

https://thecynical.dev/posts/ticket-driven-development/

Dependencies, Scrum of Scrums, and SAFe

Tags: tech, scrum, safe, project-management, dependencies, organization, agile

Definitely this, as projects scale, keeping an eye on dependencies between teams is key to efficient allocation. This will happen by trying to eliminate said dependencies, reallocating between teams.

https://ronjeffries.com/articles/2015-02-08-dependencies/

Visualizing Progress with Agile Storymapping

Tags: tech, agile, project-management

A bit of a forgotten approach I think. A good way to quickly gauge projects, show the amount of work and spot the dependencies.

https://uxmag.com/articles/visualizing-progress-with-agile-storymapping

What accomplishments sound like on software engineering resumes

Tags: tech, hr, hiring, interviews

Good advice. Since I got to review quite a few… I’d like to see them more like that. The worst part is when one also fails to point his accomplishments during the interview. I ask specific questions about this and most time get nothing meaningful in return.

https://jacobian.org/2020/may/8/engineering-resume-accomplishments/

The Tyranny of Stuctureless

Tags: organization, community, politics, decision-making

An old paper which is still very relevant today. It’s very much written in the context of the early women’s liberation movement, and yet the lessons a much more broadly applicable.

https://www.jofreeman.com/joreen/tyranny.htm

Bye for now!

If you are a developer and your KDE project is still based on Qt5 you should really really start porting to Qt6 now. 

https://mail.kde.org/pipermail/kde-devel/2025-June/003742.html

Dear fans of music & open source music players,
in preparation of the upcoming Amarok 3.3 release, a second beta release (3.2.82) has been prepared.

This time, the most important change is the new GStreamer-based audio backend. This enables a number of features that weren't available on Qt6 Phonon backends, and likely also provides a more reliable audio experience in general. In addition to audio system work, e.g. more safeguards have been set up around collection scanning code to prevent some potential database issues. More details on changes are listed in the ChangeLog.

These come in addition to the previous beta 1 changes (Qt6 only, database update). Please note that due to the database update in beta 1, downgrading from 3.3 betas is not directly possible, and returning to pre-3.3 versions requires the database (at ~/.local/share/amarok/mysqle/) to be manually backed up beforehand.

Additionally, there isn't an official release with Qt6 support of liblastfm available yet (needed for last.fm support). To enable last.fm functionalities, one needs to use a library version built from e.g. sources at https://github.com/Mazhoon/liblastfm/tree/81e8f9dc16a0a18fe9a066d51c2071086326670b

The Amarok 3.3 beta 2 source tarball is available on download.kde.org and it has been signed with Tuomas Nurmi's GPG key. In addition to the source code, it is likely that some distributions will provide beta packages. The various nightly git builds provided by various splendid packagers should also provide a way of using the beta changes and participating in the testing.

Happy listening!

Those of you upgrading to Plasma 6.4.1 (released yesterday) may notice a more substantive change than the type we typically make in bug-fix releases: The “highlight window” effect for Task Manager thumbnails is now off by default. This is the effect that makes other windows fade out when you hover over a window’s thumbnail.

Why did we turn it off? Because we discovered that with certain window arrangements and mouse movements, the current implementation could potentially cause full-screen flickering at greater than 3 Hz, which is potentially capable of triggering seizures in sensitive people.

Now, this is very unlikely. You’d need to open multiple full-screen windows of the same app, hover over their task to show thumbnails for them, move the pointer over one of the thumbnails, and then move it rapidly across all the others.

…Unlikely, but not impossible! And until and unless we can fix the effect to not be so flickery with this specific usage, it’s safer to keep it off. Furthermore, even for people who aren’t photosensitive, it’s currently a really unpleasant visual effect.

This work was done as a part of KDE’s recent accessibility push, and specifically the focused effort to make Plasma fully compliant with new EU accessibility regulations. Work is currently going on at all levels of the software stack, with multiple people involved and multiple sponsors funding it — both KDE e.V. itself, and also outside firms and institutions. If you’d like to see more of this kind of thing, donating to KDE e.V. is always a great idea, as it allows KDE e.V. itself to support an even larger amount and proportion of it.

There seems to be a bit of a doom-and-gloom vibe about accessibility in our community lately, but hopefully it’s clear that not only does KDE care, but it puts its money where its mouth is on this topic! Maybe we’re not 100% there yet, but we’re pointed in the right direction and motivated to continue accelerating towards it.

At Qt, we often say it's not just about building software—it's about building something that matters. And when you talk to people who’ve spent years in the craft, you realize it's also about finding the right tools, the right community, and the freedom to create. In this Qt Journey series, we highlight stories from developers, designers, and engineers around the world who have made Qt part of their professional lives. 

The latest updates to qmlformat, Qt's own tool for formatting of QML files, bring two practical improvements: configurable line breaking and automatic import sorting. These features enhance code readability and maintainability, making them valuable additions worth highlighting.