Welcome to my new blog.
This is the successor of my previous blog on https://dragotin.wordpress.com.
After paying wordpress quite some money to get an advertise free blog I decided to get rid of that and have my own hosted blog where I do not have to pay for not having battle ships or girls underneath my articles. Yes, that is true: Readers sent me screenshots with this kind of images.
So I am starting this journey here with Hugo. Let’s see how that turns out :-)
I’m happy to announce that the support for WebVTT format and all the nice features that it brings is finished.
Along with reading and writing of WebVTT subtitles, Subtitle Composer can now fully understand CSS - Cascading Style Sheets, subtitle positions and alignment.
A new panel has been added that allows syntax-higlighted CSS editing and subtitle position/alignment adjustment. Of course all edits are visible everywhere in app in realtime.
Some user interface elements are still being worked on and should be available in following days, in particular:
Release 0.8.0 is planned once above list is done and potential bugs that come up are resolved. Depending on community interest - ASS/SSA format improvements could be done to benefit from things that WebVTT support brought.
As usual you can try out precompiled binaries or AppImage of git development version (the subtitlecomposer-git package)
from download page or build it yourself from invent.kde.org.
I’ve just made a new 5.3.1 release of Grantlee. The 5.3.0 release had some build issues with Qt 6 which should now be resolved with version 5.3.1.
Unlike previous releases, this release will not appear on http://www.grantlee.org/downloads/. I’ll be turning off grantlee.org soon. All previous releases have already been uploaded to https://github.com/steveire/grantlee/releases.
The continuation of Grantlee for Qt 6 is happening as KTextTemplate so as not to be constrained by my lack of availability. I’ll only make new Grantlee patch releases as needed to fix any issues that come up in the meantime.
Many thanks to the KDE community for taking up stewardship and ownership of this library!
Let’s go for my web review for the week 2022-45.
Tags: tech, programming, ai, machine-learning
Very early days for research on this topic and the sample is rather small still. That said the results are interesting, there seems to have a few biases inherent to the use of such an assistant, there’s also clearly a link between the AI agency and the quality of what gets produced. We’ll see if those result holds to larger studies.
https://arxiv.org/pdf/2211.03622.pdf
Tags: tech, microsoft, surveillance
Indeed in the context of the feature it kind of make sense… still, where was the consent or the warning to the user?
https://rogermexico.bearblog.dev/microsoft-is-phoning-home-the-content-of-your-powerpoint-slides/
Tags: tech, framasoft
An important project in my opinion, glad to see it’s moving forward at a nice pace.
https://framablog.org/2022/11/08/mobilizon-v3-find-events-and-groups-throughout-the-fediverse/
Tags: tech, tools, command-line
OK, that looks like shell history on steroids. Definitely something I will try out.
https://github.com/ddworken/hishtory
Tags: tech, docker, chroot
A good reminder of what’s truly at the root of the container idea.
https://earthly.dev/blog/chroot/
Tags: tech, tests, tdd, design
Indeed, I encounter that same idea in some people. I’m unsure where it comes from, it feels like reading and extrapolating from something more reasonable (it’s like the “one test per line” I sometimes hear about). Bad idea indeed, it’s fine to have several assertions, it’s probably often required to avoid complexity explosion in your tests. This of course doesn’t mean your test should become unfocused.
https://stackoverflow.blog/2022/11/03/multiple-assertions-per-test-are-fine/
Tags: tech, developer-experience
Very important topic. Nice to see more such teams appearing and thinking now focusing on how to structure them.
https://leaddev.com/productivity-eng-velocity/what-developer-experience-team
Tags: tech, architecture, funny, java
OK, this is funny. Clear over-engineering non sense for the sake of it.
https://github.com/EnterpriseQualityCoding/FizzBuzzEnterpriseEdition
Tags: business, management, leadership, strategy
Interesting framework for sustaining a strategic train of thoughts for the long term. This can’t be a fix thing, it needs to live and breather which this approach seems to foster.
https://www.lenareinhard.com/articles/how-to-lead-strategically-every-day
Tags: business, strategy
Nice succinct form to present a strategy.
https://medium.com/@sheacole08/how-to-present-a-strategy-in-6-slides-1c4df52ca23
Tags: tech, project-management, failure
Interesting story on how power plays can sometimes completely hide the fate of a project until it’s too late. Definitely a cautionary tale.
https://doomedprojects.com/post/it-would-be-career-limiting
Tags: tech, ai, machine-learning, optimization, science, politics, economics
Interesting food for thought. Not necessarily easy to see it used in as many fields as the article claims. Maybe a bit too much on the techno solutionist side at times. Still, that sounds like an interesting guideline and path to explore.
https://sohl-dickstein.github.io/2022/11/06/strong-Goodhart.html
Tags: management, business, work, burnout
Interesting take on burnout as an organizational phenomenon and the consequences. This is not simply about the amount of work.
https://writing.pupius.co.uk/burned-out-its-not-you-869ecce65270
Tags: psychology, linguistics, problem-solving
Indeed, be careful when using “just”. It’s often doing more harm than anything.
https://www.tbray.org/ongoing/When/202x/2022/11/07/Just-Dont
Tags: genomics, biology, science
Oh that looks really cool… will need quite some time to go through this though.
Bye for now!
Monthly update on KDE/Plasma on Debian: Updates to Frameworks and KDE Gears
Short summary of recent changes and updates:
dragotin
@herzenschein:kde.org
plasma524) has been updated to the latest patch level 5.24.7If you see some strange behavior, please report.
Debian unstable and testing already have (albeit outdated) packages for Plasma 5.26, and I have tried to package and build it for all the releases including Debian/stable. Unfortunately, Plasma 5.26 has a hard dependency onto a version of libDRM that is not available in Debian/stable, and thus compilation on Debian/stable does not succeed.
This makes my work regarding Plasma 5.26 far less useful, and thus I am currently not working on 5.26.
I repeat (and update) instructions for all here, updated to use deb822 format (thanks to various comments on the blog here):
curl -fsSL https://www.preining.info/obs-npreining.asc | sudo tee /usr/local/share/keyrings/obs-npreining.asc
/etc/apt/sources.lists.d/obs-npreining-kde.sources, replacing the DISTRIBUTION part with one of Debian_11 (for Bullseye), Debian_Testing, or Debian_Unstable:# deb822 source: # https://www.preining.info/blog/tag/kde/ Types: deb URIs: https://download.opensuse.org/repositories/home:/npreining:/debian-kde:/other-deps/DISTRIBUTION https://download.opensuse.org/repositories/home:/npreining:/debian-kde:/frameworks/DISTRIBUTION https://download.opensuse.org/repositories/home:/npreining:/debian-kde:/plasma525/DISTRIBUTION https://download.opensuse.org/repositories/home:/npreining:/debian-kde:/apps2208/DISTRIBUTION https://download.opensuse.org/repositories/home:/npreining:/debian-kde:/other/DISTRIBUTION Suites: / Signed-By: /usr/local/share/keyrings/obs-npreining.asc Enabled: yes
You can use also plasma524 instead of plasma525 if you prefer the LTS version of Plasma.
Enjoy!
tl;dr : There is nothing wrong with any of the mechanisms in the subject, you just have to be careful when combining them all.
Long title, but the combination is important. Recently, I had an embedded device on my desk, which drove me to claiming quite strongly that “this is not possible what is happening in front of me!!!” If you are familiar with setups of all the points above, this article might be interesting to you.
Starting from the very strange effects I had. The device itself in question has a read-only root file system, as it is common for embedded devices. On this device a QtQuick application is running and, because I have not the most efficient processor, QML cache is enabled. Instead of going the build-time cache generation route, I have a persistent writable partition on the device, on which the QML cache is generated and stored at first start of the QtQuick application after first boot. Note that the cache needs to be persistently stored since otherwise the whole performance improvement on startup is moot.
So far so good, everything works well… until we are starting to update the software or more precisely the root file system. For this example, and this will be important later, the update of the root file system just updates my QtQuick application and its QML file but not the Qt version. What I then see after the update and the following boot is a system where the QML application still looks like before the update. Looking deeper at the file system, everything seems fine, files are updated, even QML files are updated, but the application just ignores them. But even worse, the application now randomly crashes because the executable and the shared libraries apparently do not match to the QML code being executed. — I will shorten this up, because with the intro the problem is quite obvious: the QML cache is not being invalidated even if it should and old versions of the QML files are used to run the applications. But how can this be?!
All the magic that decides if the cache file is up to date or not essentially is located in qv4executablecompilationunit.cpp. Reading that code, we find the following checks:
I do not think that much further explanations are required that tell why this can break fundamentally when we are building a root file system image in some environment like Yocto that fixes all timestamps in order to make builds reproducible (Many thanks to the NixOS folks for their initial analysis! Apparently we independently hit this issue at nearly the same time.)
Ok, we now know that the modified timestamp of the QML file (this is what eg. “stat -c%Y MyFile.qml” gives you as result) is the key ingredient for making the cache working correctly in our setting. For this, we have to differentiate between two ways how QML files might land on our root file system:
The first case is fairly simple. Here, we have to look into the process on how the root file system image is created (in case of package based distros this is different and you have to check how the packaging system is handling this!). In my case, the root file system is generated by Yocto and there is a global BitBake value called REPRODUCIBLE_TIMESTAMP_ROOTFS, which forces all files inside the root file system to have the same modified time stamp during image creation.
The second case is more interesting though. Here the SOURCE_DATE_EPOCH environment variable is used to set the modified date of the source files to a certain value. Note that one needs such a mechanism in order to make the build really reproducible because one cannot rely on the file date extracted or checkout out sources, which also may further change due to patches being applied during the build process. Rather, we want to use the timestamp of the last commit or a timestamp that is baked into a release tarball.
Yocto, as most modern meta build systems, does exactly this and sets this value for the build from the source data (for details look into Poky). Further, rcc (Qt’s resource compiler) picks this value up and sets the modified timestamps of the QML files correctly while baking the files into the binaries.
Since Yocto already handles SOURCE_DATA_EPOCH correctly, just use a fixed REPRODUCIBLE_TIMESTAMP_ROOTFS and be happy 
And here, I urge you to not try workarounds like setting REPRODUCIBLE_TIMESTAMP_ROOTFS=””, because this triggers fallbacks at different places of the code. Eg. you will find /etc/timestamp being the actual time of the build but then you will note later that the modified time stamp of the files in the root file system is now the date of the latest Poky revision. Funny, heh ;D So, never rely of fallbacks, because the tend to be inconsistent.
A much better way is to couple the rootfs timestamp in your project to something that is regularly updated, at least once for every release. I am in the lucky position to usually have a meta-layer/submodule with release notes where I know for sure that there is a commit before every release. Thus, I can simply add the following line in my conf/local.conf:
REPRODUCIBLE_TIMESTAMP_ROOTFS:="${@os.popen('git -C "$BBPATH/../sources/my-layer" log -1 --pretty=%ct 2>/dev/null').read().rstrip()}"It is not that important what exactly to use to initialize the timestamp, as long as it changes often enough, as long as it still makes your build reproducible.
And again, you only have to really worry about all of the above if you have a QML cache on a persistent partition while updating the root files system.
(German version: https://wordsmith.social/felixernst/dolphin-treffen-bei-barcelona)
Among my contributions towards KDE I am probably best known for becoming a dolphin maintainer recently. “Maintainers” are the people most responsible for something, and I share this responsibility with Méven Car these days.
The plan was to have a dolphin meeting at Barcelona, so I set off.
I think the most important topic for a self-organising and -acting international group like us, that swims in all seven seas, is that we meet from time to time at a coast to talk about common goals. Otherwise, everyone surfs and browses wherever the streams pulls them. Everyone has an idea about what is currently the most important thing to get to and then simply swims there as directly as they can. However sometimes it makes sense to discuss what really is the most important area to focus on. And that is exactly the topic I have chosen for our dolphin meeting.
It was new to me to act in a leading organisational role within KDE. Not only concerning Dolphin but also more generally within the ecosystem of penguin fans.
Okay, I think I have to drop the Doublespeak here because technical terms become necessary. To avoid any further confusion, I'll clarify now: Dolphin is an application. To be more precise: It is the default file manager of KDE. Méven Car and I share the responsibility of maintaining it. The text above wasn't really about animals at all!
We did meet in Barcelona and tried to figure out where the biggest areas of improvement for Dolphin might be.
Neal Grompa, who brings KDE's software to Fedora and other distributions, had the idea that Dolphin should have a feature that allows users to restore older states of files and folders. The practical application of this would for example be that a user — after ruining a report or article — could simply bring back an older version of that file. Or that someone — after accidentally deleting a file — could restore an older version of the folder containing that file and therefore restore the file itself.
Does that sound like magic to you? Is it even possible? Wouldn't it be necessary to have some sort of backup for this to work?
The answer to all these questions is “Yes”. You might not yet be aware that some modern file systems, which you might already be using while you are reading this, are already keeping old data around. They do this so that you can bring your computer back into a working condition if your system ever becomes dysfunctional. Popular file systems which have this as an integrated feature are BTRFS and ZFS.
While exploring the sights of Barcelona with Luca Weiss and Arjen Hiemstra, we discussed how such a time travel feature could be implemented in Dolphin, and I also researched the topic a bit on my own later: The problem I am currently seeing is that it is difficult to pinpoint where in the file system the older versions of files and folders are located. It turns out that at least for BTRFS there is no mandatory folder structure. While it is normally reasonably easy for users to find the old versions (e.g. in openSuse in “/.snapshot/SNAPSHOTNUMBER/snapshot”) the names could be anything, the age of the backup is not necessarily stored in an easily accessible manner either, and figuring out which files belong together isn't trivial either. What do we do if the file that should be restored has been moved to a different folder in the meantime?
Maybe I am missing something, but I am having difficulty inventing a reliable approach even if I ignore all the technical details for the moment. That doesn't mean that the project is impossible to implement. Not at all! Worst case one could simply search the full disk. However, I have to admit that this is too big of a project to programme on the side. If you are interested or capable to implement this nicely you would be the hero of some users who would otherwise not know how to recover the data. I am certain of that.
One would probably implement it as a KAbstractFileItemActionPlugin which opens a window in which the user could choose the version of the file or folder they want to restore.
In a way the most important thing for a file manager is that it quickly displays the data on storage media. We don't want the name Dolphin to only be for show: A dolphin is fast (fastest mammal in water at 64 km/h). Nothing blocks it in the oceans.
Disks, on the other hand, can be blocking which can be a problem for the other Dolphin. It might take a while for them to retrieve data especially when they are accessed over the internet or another “slow” network. But the access being slow isn't really a good excuse for Dolphin to stutter as well. Loading of data can obviously take some time but Dolphin should stay responsive and quick regardless of that.
More details on this topic can be found in our meeting notes: https://invent.kde.org/system/dolphin/-/issues/35#note_535555
With some regularity users complain about data loss because they removed a storage device after the data transfer has been reported as completed.
In KDE we report a file transfer as complete when the Linux-kernel reports to us that the transfer is complete. Unfortunately, that isn't the full truth because the Linux kernel is a bit hasty in that regard. It considers a transfer as complete as soon as the data is “accessible from the new location.” However, that is a while before the data has actually been physically transferred.
I see three solutions to this: 1. Linux gains a new option so the reported transfer progress is based on physical data transfer progress. 2. We make sure ourselves that the transfer is complete before we report that it is. 3. (In the words of Kai Uwe Broulik:) “We show a very very angry message to the user when they unplug a device that is still mounted, so they will learn not to do that!”
As you might know, the Linux security model can deal with multiple user accounts that act on the same data. Depending on the specific file or folder, different users can have different permissions when it comes to accessing, changing or executing the data.
The account that has full access to all data on the computer is typically called “root”. It is the administrator account on pretty much every computer.
If a user tries to run Dolphin with all the permissions of an administrator by using the programme “sudo”, which would allow them to edit any data on the file system, Dolphin denies this. The reason for this is that this action could potentially allow a hacker to seize full control over the computer. This blockade was put in place before I was part of KDE but users are still annoyed by it because it makes certain tasks more difficult for them. How can we improve this situation without introducing new security hazards for companies and users alike?
Harald Sitter created an alternative, more secure method (https://apachelog.wordpress.com/2022/08/04/kio-admin/) which allows users to manipulate all data. We might integrate it better into Dolphin eventually.
I also recently discussed a different more immediate solution with Nate Graham: We know that in the past years various methods have emerged to bypass the blockade. These methods, that reduce security, are quite popular. The blockade in Dolphin doesn't really stop users who want to do an insecure thing. So instead of trying to hinder users more effectively, we should take the chance and inform them about the dangers of what they are trying to do. If they still want to continue after that, we can't and shouldn't stop them. It could be a good idea to transform the block into more of a lock with an easy way to open it legitimately.
So much for what was discussed at the Dolphin Meeting. The rest of this article is about other topics that are relevant to me.
In Barcelona I talked a lot with the young developers who strive to make an adapted version of KDE Plasma a success on mobile phones. I hope this software will soon become a viable alternative to Google's Android for the average user. There is some interest to have the file manager that people know and love from their computer also available on their phone.
They didn't know — and neither do you probably — that Dolphin is already so flexible and touch-friendly that not too much work should be necessary to bring Dolphin in a state that is nice to use on phones:
We would probably need a separate configuration for phones, so users can easily install Dolphin in such a fitted state. Are you interested in making Dolphin shine in the mobile space? Contributions are always welcome!
I talked with Joseph P. De Veaugh-Geiss, who supports the eco-friendly “Blauer Engel For FOSS” project, about the possibility of also certifying Dolphin with the “Blauer Engel”. Question is: What are the direct benefits we expect from such a move? Eventually, it could push governmental institutions towards using Dolphin but Joseph explained that they probably wouldn't switch to Linux for this alone. To his surprise — and maybe yours too — Dolphin already works on Microsoft Windows and to my knowledge even on macOS. It has some rough edges on Windows and nobody really takes care of those at the moment. Would that be worthwhile? If we were to popularise the Windows version, would that lead to a lot more free and eco-friendly computing? I am not sure if we shouldn't rather use our limited resources on other things.
You might notice by now that there is way more meaningful work to do in Dolphin alone than we can realistically undertake with our small group of volunteer developers. It would be great if even more friendly contributors would join the project all of a sudden. :)
Another topic that is dear to my heart is that our software should also be usable by computer-illiterate users. We accomplish this with guides and help texts among other things. Some of my efforts to have more help available were successful. One example are the little help buttons which have made their way to various parts of KDE by now after I introduced them on the “Fonts” settings page only two years ago (https://invent.kde.org/plasma/plasma-desktop/-/merge_requests/51). In a similar vein I added a feature to many applications that allows users to invoke exhaustive help directly from an application's user interface. You might have noticed the little “Press Shift for more.”-notes which for example show up when you hover your mouse cursor over a button in Dolphin. In my opinion every KDE application should provide more help this way.
I was in the meeting about writing guides and documentation for the web page https://userbase.kde.org/Welcome_to_KDE_UserBase and tried to promote the idea there that it might make more sense in many cases to have help available directly where it is needed: in the application. Unfortunately, I didn't get the impression that I was able to convince the attendees of that. So instead, I'll repeat here that every step we put between the user and the available help leads to less users actually using that help. When a user wants to know what a button does, the help should be available right there either next to the button or invokable directly from the button.
On a positive note I noticed that some KDE contributors have already figured out the benefits of this feature. Kai is a fan for example. I hope it is only a matter of time until this new way of providing help is used as naturally as the two-year-old little help buttons are by now in system settings.
So much about my endeavours. If you read with interest until now, you might also be interested in my videos about KDE development: https://tube.tchncs.de/c/felix_ernst/videos
Meeting the unique group that traveled to Akademy 2022 in Barcelona this year held many benefits for our future collaborations and therefore ultimately for our software. The text above is already way too long even though I nearly exclusively talked about Dolphin. So many other topics would be worth mentioning. Above all else how great it was for me to meet all these friendly KDE contributors in person for the first time.
I would like to thank KDE e.V. and the many donors to that organisation for paying the majority of my travel expenses. After personally meeting the people who manage the donation money, I can say with full confidence that donation to the KDE e.V. are in good hands and spent with diligence and strategy to ensure the long-term existence and growth of the wider KDE community. If you would like to donate to this non-profit entity, visit https://kde.org/community/donations/.
Let’s go for my web review for the week 2022-44.
Tags: tech, twitter, attention-economy
Spot on analysis. What could Musk do with Twitter? Why? Several theories but clearly this will impact and distort even more the information landscape.
https://affordance.framasoft.org/2022/10/the-bird-the-billionaire-and-the-precipice/
Tags: tech, agile, criticism, safe
Finally out of Google Docs it seems. Better version for sharing around. Still an interesting list of case studies and opinions around SAFe. I learned a few things, I didn’t realize it’s creation was so disconnected from the pre-existing agile community. It all seems to confirm my opinion that it’s better to stay away from it though. The few organizations I know of which use it are clearly very much in a command and control mode. This is going backwards.
Tags: tech, python, security, supply-chain
OK, this is a weird but real supply chain attack on going in the Python ecosystem.
Tags: tech, kde
Always pleasant to see a nice and positive review!
https://www.dedoimedo.com/computers/plasma-5-26-review.html
Tags: tech, programming, safety, type-systems
Definitely this! It’s important to model properly your domain and leverage smart value types everywhere it makes sense. This can prevent quite a few different types of bugs.
https://dusted.codes/the-type-system-is-a-programmers-best-friend
Tags: tech, programming, optimization, performance
Good reminder that “premature” doesn’t mean “early”. Poor Knuth is so often badly quoted in the context of optimization that it’s really sad. The number of times I see “early pessimisation” on the pretense of avoiding “premature optimization”. Such a waste…
https://pythonspeed.com/articles/premature-optimization/
Tags: tech, programming, optimization
What the title said, there’s nothing fancy about optimizations. It’s mostly well known knowledge, doesn’t change much over time or on different stacks… still it’s very satisfying.
https://pythonspeed.com/articles/old-fashioned-software-optimized/
Tags: tech, communication, writing
If you like remote work, then you need to make sure your written communication is good. There’s a handful of proper guidelines in this paper. Good reminders.
https://www.karlsutt.com/articles/communicating-effectively-as-a-developer/
Bye for now!
