Skip to content

Sunday, 30 May 2021

After gaining some experience being a GSoC (backup) mentor last year I am mentoring a GSoC student again this year. As it worked out to have a co-mentor, I could convince Ralf to join me in this role to support Suraj Kumar Mahto in his project to replace the current KMyMoney online quote support with the general online quote functionality found in the Alkimia library. The Alkimia version provides a lot more functionality for the end user and is already found in the KMyMoney version based on KDE4. Suraj already brings some experience of working in and with the KDE community and contributed to multiple projects in the last year.

Vice versa, I am co-mentoring Ralf’s student on his quest to add pretty printers for debugging support of Qt/KDE applications. Ebuka is currently using the Community Bonding phase to get acquainted with the KDE community, its procedures, infrastructure and alike.

As an initial step to, Ralf and I setup a video conference with each of them this weekend. I am thankful to my employer that we can use the company’s infrastructure for it also in the future. We had an hour with each of them to get to know each other, see some faces behind the names, e-mail addresses and irc/matrix/telegram nicks. We exchanged some details about our and their educational, professional and private lives. Regarding the projects, we walked through the proposed timelines and also dove a bit into code issues and questions the students had. This should provide a good base for the weeks ahead.

I think, we laid the ground for both projects to succeed and now count on the students to get started and productive. After all, it’s usually 10% inspiration and 90% transpiration. Ralf and I wish them luck and promised to provide help wherever possible.

Friday, 28 May 2021

We are happy to publish a new release of Kaidan that brings it closer to fulfilling the daily messaging needs.

As promised, this release includes some major new features: The chat history is now being synchronized across devices, to allow finding information in old messages. It is now indicated when the chat partner is typing, which makes conversations easier.

Typing notifications in action

We have also polished the general usability, so that now the size of the windows is preserved across restarts. Some of the strings in the user interface have received some rewording, to make them easier to understand.

The registration now integrates as good as possible with servers which have registration through chat apps disabled, by showing the link to register through the server’s website.

On the cross-platform side, we have decided to use the breeze theme also on macOS, as the macOS style does not support a few features we want to use in the user interface.

Changelog

This release adds the following features:

  • Add typing notifications (XEP-0085: Chat State Notifications)
  • Add message history syncing (XEP-0313: Message Archive Management)
  • Window size is restored
  • The server’s website link is displayed if account creation is disabled
  • Use breeze theme on macOS
  • Improved user strings & descriptions

Download

Or install Kaidan from your distribution:

Packaging status

Let’s go for my web review for the week 2021-21.


World now likely to hit watershed 1.5 °C rise in next five years, warns UN weather agency | | UN News

Tags: climate

Maybe it’s time governments get real about this?

https://news.un.org/en/story/2021/05/1092842


One Man’s Fight for the Right to Repair Broken MacBooks

Tags: tech, repair

Important advocacy, the right to repair has to become huge in the coming years.

https://columbianewsservice.com/2021/05/21/one-mans-fight-for-the-right-to-repair-broken-macbooks/


affordance.info: Guillaume Rozier : le chevalier Scraper et sans reproches.

Tags: covidtracker, healthdatahub

Article in French

What is the existence of CovidTracker, the definition of the HealthDataHub and the communication around them by the French Government says about the abilities and mindset of the French State? Not much good… it’s basically about trumping individualism and abandoning the regalian to the platforms even more.

https://www.affordance.info/mon_weblog/2021/05/guillaume-rozier-chevalier-scraper.html


So. They know my mom’s toothpaste….

Tags: tech, metadata, surveillance

If you still wonder how ads work on the web and on mobile, this thread summarizes it well. They just farm us.

https://nitter.fdn.fr/RobertGReeve/status/1397038375840985089


Freenode IRC operators now engaging in routine abuses of power

Tags: tech, irc, freenode

Well… That escalated quickly it seems. Clearly we can’t trust that network anymore.

https://www.devever.net/~hl/freenode_abuse


Upheaval at freenode [LWN.net]

Tags: tech, irc, freenode

The Freenode drama keeps unfolding… disgusting.

https://lwn.net/Articles/857252/


One week of Libera Chat | Libera Chat

Tags: tech, irc, freenode, liberachat

At least it looks like they’re doing well for now. Let’s hope it keeps growing.

https://libera.chat/news/one-week-of-libera-chat


Learn CSS

Tags: tech, web, frontend, css

Looks like a very comprehensive course about CSS.

https://web.dev/learn/css/


voice2json | Command-line tools for speech and intent recognition on Linux

Tags: tech, ai, speech, intent

Looks like an interesting engine for offline intent recognition.

https://voice2json.org/


Why Decentralised Applications Don’t Work

Tags: tech, fediverse

This is definitely not for technical reasons only. Another case of “this is not a tool problem”, it’s really politics.

https://ingrids.space/posts/why-distributed-systems-dont-work/


Client Tracing: Understanding Mobile and Desktop Application Performance at Scale - Slack Engineering

Tags: tech, logging, tracing

Interesting article about tracing, especially on the client side and how to correlate it with the server side tracing.

https://slack.engineering/client-tracing-understanding-mobile-and-desktop-application-performance-at-scale/


Arm Announces Mobile Armv9 CPU Microarchitectures: Cortex-X2, Cortex-A710 & Cortex-A510

Tags: tech, cpu, arm

Quite some movement in the ARM space. Interesting stuff.

https://www.anandtech.com/show/16693/arm-announces-mobile-armv9-cpu-microarchitectures-cortexx2-cortexa710-cortexa510


It’s probably time to stop recommending Clean Code @ Things Of Interest

Tags: tech, programming, craftsmanship, book

Interestingly, I’m going through this book right now and indeed I have to agree with most of this article. It didn’t age well, it’s become a mix of nice advises, things which are kind of obvious nowadays and points which are clearly obsolete. I find that “The Clean Coder” (different topic I know) aged way better. I think I’ll give a shot to the proposed alternative book to see…

https://qntm.org/clean


My Software Estimation Technique - Jacob Kaplan-Moss

Tags: tech, estimates

Looks like an interesting alternative to three point estimates. Indeed it feels a bit more complex at first but in practice it might require less discipline than three point estimates. Often three point estimates can devolve into forced distribution for tasks. I have already seen enough time cases where most likely is always say twice the optimistic case, and pessimistic four times the optimistic case for all tasks. By forcing to explicitly treat the uncertainty as a separate metric it’s seems less error prone.

https://jacobian.org/2021/may/25/my-estimation-technique/


Second-guessing the modern web - macwright.com

Tags: tech, web, frontend, react

I think this piece is getting quite a few points right. The SPA for everything trend rubs me the wrong way at least. As usual: use the right tool for the job.

https://macwright.com/2020/05/10/spa-fatigue.html


M-

Tags: tech, web, javascript, frontend

In my question for simpler web frontends, this looks like an interesting library. It’s built on Custom Elements (part of the Web Components effort) and is just a tiny bit of Javascript. Sounds neat and tidy.

http://m-docs.org/


Dorodango, the Japanese art of making mud balls - Laurence King Blog

Tags: art, surprising, japan

Interesting art form, I didn’t know about it. This is fascinating how an activity so humble can be turned into something seeking some sort of perfection.

https://www.laurenceking.com/blog/2019/09/26/dorodango-blog/


What Are You Doing With Your Life? The Tail End - YouTube

Tags: philosophy

Another way to get into “carpe diem” mode I guess. :-)

https://www.youtube.com/watch?v=JXeJANDKwDc



Bye for now!

Tuesday, 25 May 2021

KDE DEVLOG 4: Finishing Up the Active Applet Indicator!

KDE DEVLOG 4: Finishing Up the Active Applet Indicator!

A few weeks ago, the Krita project announced the Krita Dev Fund. This project scope was the same as the Blender Dev Fund. Provide a stable way to fund the development of Krita via recurring donations.

Since I was the one who helped with the technical bits on the website and I heard that were are interested FOSS communities that want to deploy something similar, I decided to write a small tech report about how we did it in Krita.

Luckily for us, when we started researching how to create something similar, we rapidly discovered that the Blender Fund website itself is open source and licensed under the same license as Blender: GPL. It made it easy to reuse the code.

The system is written with Django for the backend and uses Braintree as a payment provider. The code was built with Blender need in mind and not as a reusable project that I could use without any change, so a fork was inevitable. To make the maintenance more manageable, I decided to try to stay as near as possible to upstream in our Python code so that it’s easy to rebase the Krita fork when needed.

The code is hosted on invent.

Blender Fund is using its own authentification system (Blender ID) using OAuth2. To connect to Blender Id, a separate Django module for authentification exists (blender-id-oauth-client). This could be replaced by a custom implementation using default Django auth module or one of the many third-party Django ready-to-use authentification modules. In the case of Krita I just used blender-id-oauth-client with a few oauth2 parameters changed.

The most significant modifications I made were mainly around the HTML templates and CSS files. Most of these modifications were about replacing Blender with Krita, and updating the look of the homepage. We couldn’t just use Blender’s branding!

There was also quite a bit of work with the layouts of the page since Krita main CSS theme is using Bootstrap 3 and the Blender Fund website is using Bootstrap 4 and were was many subtle differences between both versions.

Updating only the templates made it possible to customize the website’s look and edit the content of the emails sends by the system to use Krita billing information instead of Blender one.

In terms of Python code changed, there was also a few instances of ‘Blender’ that got replaced by ‘Krita’. But all the other changes than were minors. For example, I added back the progress bar on the landing page since Blender removed it from fund.blender.org since it wasn’t needed anymore. Another small change was adding to the homepage the amount of the current donation from the old system.

A few weeks before launching fund.krita.org, I got a pleasant surprise as I wanted to rebase my prototype on top of upstream before moving Krita Fund to production. I discovered that the Blender team moved their internal library that handles all the payments to a separate library. It instantly made the amount of critical code in Krita’s fork smaller and my life much simpler.

That’s it! So if you want to support Krita and help them build the best painting application in the world and available for everyone, make sure to check out the Krita Fund.

And if you are enjoying my work all around KDE (Plasma Mobile, NeoChat, websites, …), feel free to check out my Liberapay account.

Monday, 24 May 2021

In the past I’ve always been struggeling with asynchronous and yet simple database access with QtSql. I now came up with a quite nice solution and I hope I can help you with it.

Multithreading in Qt

When working with Qt most of the time you do not need to care about threading. Most things already work asynchronously, they don’t block and there’s no reason to mess with additional threads. This is the case for network requests via the QNetworkAccessManager where signals are used (as pretty much everywhere). If you’ve got other tasks like hash calculation of large files or image scaling, then there’s QtConcurrent::run() for you which will execute a function on the application’s thread pool.

QtConcurrent uses QFutures to report the results. In Qt 5 QFutures are not very handy (you need a QFutureWatcher to get the results asynchronously and you manually need to create and delete it). With Qt 6 this has changed and now there’s a pretty nice QFuture::then() function where you can directly pass a lambda handling the result:

QtConcurrent::run([]() {
    // do heavy calculations ...
    return value;
}).then([](Result value) {
    qDebug() << "Calculation done:" << value;
});

This simple way to chain QFutures creates a nice flow in your code. Instead of having (maybe multiple) slots that all need to be connected, here you can just write your code directly behind the QtConcurrent::run() call.

Databases and threading

That’s all pretty nice, but it doesn’t work with databases. You can’t just open a QSqlDatabase and execute queries on it via QtConcurrent. Most (if not all) SQL database drivers are going to complain that you’re using the database from the wrong thread. So, what you need to do is creating the database on the same thread as where the queries are executed. This means we can’t use QtConcurrent (at least not without some adjustments) since we don’t know on which thread our job is going to be executed.

Solution #1: Thread-Worker model with signals

My first idea on how to solve this and how I also did it in the past was creating a normal QThread and a database worker class running on the thread. The database is opened on this new thread and all queries are also executed on it. Now with this approach we somehow need to trigger queries and receive their results. Qt offers signals and slots with queued connections for this. My approach was to create two signals and a slot on the database worker. Let’s look at an example here:

class DatabaseWorker : public QObject
{
    Q_OBJECT
public:
    DatabaseWorker(QObject *parent = nullptr);

signals:
    void fetchAllUsersRequested();
    void allUsersFetched(const QList<User> &users);

private slots:
    void fetchAllUsers();
};
DatabaseWorker::DatabaseWorker(QObject *parent)
    : QObject(parent)
{
    connect(this, &DatabaseWorker::fetchAllUsersRequested,
            this, &DatabaseWorker::fetchAllUsers);
}

DatabaseWorker::fetchAllUsers()
{
    // ... do query ..
    emit allUsersFetched(users);
}

If you want to fetch the users, you’d do the following:

emit database->fetchAllUsersRequested();

As soon as the database has executed the query, it will emit the allUsersFetched() signal, which you can handle.

However this approach has some problems:

  1. You need to care about threading manually.
  2. You need to create signals and connect them for every new function.
  3. The caller (of fetchAllUsersRequested()) doesn’t know which request belonged to the results received from the signal (allUsersFetched()). This is not a problem in this case, but as soon as you’ve got multiple requests at the same time, this will get important.

The second point can be workarounded, but the code won’t be nice.

Solution #2: QtConcurrent with a one thread QThreadPool

Using QtConcurrent with QFutures would solve all three problems here, so we should have a deeper look at QtConcurrent. In the documentation we can see that QtConcurrent also provides the option to use a specific QThreadPool for the execution.

This helps us since with a custom thread pool we can set the maximum thread count to 1 and so this way can guarantee that everything is executed on the same thread. QThreadPool automatically deletes threads when they’re unused. We also need to prevent this, because the used thread of course must not change:

QThreadPool pool;
// limit to one thread
pool.setMaxThreadCount(1);
// prevent automatic deletion and recreation
pool.setExpiryTimeout(-1);

This basically already solved our problem. We now just need to do everything via QtConcurrent and our QThreadPool and we don’t need to care about threads at all anymore.

Our Database now could look like this:

class Database : public QObject
{
    Q_OBJECT
public:
    QFuture<void> open();

private:
    QThreadPool m_pool;
}
QFuture<void> Database::open()
{
    return QtConcurrent::run(m_pool, []() {
        auto database = QSqlDatabase::addDatabase("QSQLITE", "main-connection");
        database.setDatabaseName("/home/me/data.sqlite");
        database.open();
        // of course you should do some more checks here to see
        // whether everything went well :)
    });
}

Other queries can be done like this now:

QFuture<QList<User>> Database::fetchUsers()
{
    return QtConcurrent::run(m_pool, [this]() {
        QSqlQuery query(QSqlDatabase::database("main-connection"));
        query.exec("SELECT * FROM users");

        QList<User> users;
        while (query.next()) {
            // ...
        }
        return users;
    });
}

And with Qt 6 you can pretty easily handle the results now:

database->fetchUsers().then([](const QList<User> &users) {
    // do something
});

Unfortunately with Qt 5 it’s not so nice:

auto *watcher = new QFutureWatcher<QList<User>>();
connect(watcher, &QFutureWatcherBase::finished, [watcher]() {
    QList<User> users = watcher->result();
    // do something with the result
    watcher->deleteLater();
});
watcher->setFuture(database->fetchUsers());

This is not very nice and things can go wrong, you could forget to delete the QFutureWatcher for example. Thus, we use a template function to simplify this:

template<typename T, typename Handler>
void await(const QFuture<T> &future, QObject *context, Handler handler)
{
    auto *watcher = new QFutureWatcher<T>(context);
    QObject::connect(watcher, &QFutureWatcherBase::finished,
                     context, [watcher, handler { std::move(handler) }]() {
        handler(watcher->result());
        watcher->deleteLater();
    });
    watcher->setFuture(future);
}
await(database->fetchUsers(), this, [](QList<User> users) {
    // do something
});

And that already looks much better! :)

We now got a solution with the following features:

  1. A database class running in the main thread. No manual thread management.
  2. No signals and slots for each new function. Just QFuture::then / await.
  3. Request and result handling can be easily ‘linked’ by using lambda captures.

This is a very nice solution for most of the use cases in our applications.

Do we want anything more? – Okay, maybe parallel queries with multiple threads, for building servers or a high-performing application, but that’s probably irrelevant in most of the cases. However, maybe we’ll see this in one of the next blog posts. :)

Sunday, 23 May 2021

Hello! This is the first entry in a hopefully reoccurring series of blog posts about the KDE Goals.

The purpose of this series is to provide a frequent update about the Goals, to highlight what cool things are happening.

Of course, our Goal Champions can still create additional content about their goals in any form they want: short blog posts, videos, in-depth articles, etc. This blog will aggregate that content and also give the champions a way to share quick updates without spending too much time blogging.

And with that, let’s take a look at the updates!

Wayland

Plasma 5.22 is coming, and with that a lot of improvements and fixes to Wayland support. Readers of Nate’s blog have surely seen many of those highlighted.

Personally, I’m very excited about variable refresh rate (FreeSync) support being added. I asked Xaver, author of the merge request (and the GPU hot-plug one!) to write about the new features. Hopefully, we’ll get some juicy details soon!

Meanwhile, you can start testing Plasma 5.22 right now! David has a post about that. Be sure to report any bugs found and see if the list of Wayland showstoppers needs updating.

Consistency

Niccolo sent over a full list of recent consistency updates!

1. We are adding a new re-usable component called KHamburgerMenu that will make hamburger menus consistent throughout Plasma. It’s cool because it adapts to your toolbar: if you take an action off it will appear in the hamburger menu, and if you add an action it will disappear from it.

https://invent.kde.org/system/dolphin/-/merge_requests/168

2. Ark now has a welcome screen!

https://invent.kde.org/utilities/ark/-/merge_requests/47

3. Gwenview sidebar has been made more consistent with our current humane interface guidelines

https://invent.kde.org/graphics/gwenview/-/merge_requests/64

4. Discover now uses standard cards to display reviews instead of custom component

https://invent.kde.org/plasma/discover/-/merge_requests/80

5. Viewswitcher in libhandy now are more consistent to Plasma style

https://invent.kde.org/plasma/breeze-gtk/-/merge_requests/18

6. Calendar has been completely redesigned and now uses Plasma style elements more consistently: the top area, the vertical line like in kickoff, etc

https://invent.kde.org/plasma/plasma-workspace/-/merge_requests/727

7. Work in progress: we are bringing the highlight from Plasma everywhere on applications as well! A great step forward for our consistency goal of using the same highlight everywhere.

https://www.youtube.com/watch?v=MppOSRfFbE8

Oof, who knew there’s so much work to do just to stay consistent!

KDE is All About the Apps

In a different kind of news, Jonathan has stepped down as the Goal Champion. Thank you very much for all the work done to make KDE a better home for apps, Jonathan.

The Goal’s new champion is Aleix. He wants to start by asking the community to discuss a range of topics regarding the Goal. Here’s a list from Aleix:

  • platforms
    • linux
      • flatpak
      • appimage
      • snap
      • distros
    • bsd
    • android
    • windows
    • os x
      ??? to discuss: ways to reach the platform, our unique selling points there to focus
  • promo
    • website presence
  • business
    • making money for devs
    • fundraising for KDE
  • suites
    • PIM
    • Edu
    • Calligra
  • developer story
  • Plasma
    • Plasma & apps
      • which apps should be just considered plasma-specific/oriented? what can we leverage from this specificity?
      • what apps are we lacking?
    • Plasma mobile
    • Plasma desktop (?)
    • other form factors: TV, tablet, etc
  • Tech used
    • Kirigami and KDE Apps
    • KXMLGUI and KDE Apps

I’m sure we’ll need a couple of meetings to cover all of that! If you’re interested in participating in the discussion of ANY of those topics, please reach out specify which ones. This will help narrow down the focus of the first meeting.

Meta

While I’m not actually working on any of the Goals, I do help how I can with the KDE Goals initiative as a whole. This blog is part of that. Additionally, I plan to write a description of the Goal Champion role, since currently we don’t have anything “official”. Let me know if you have ideas about what such a description should include.

Friday, 21 May 2021

Let’s go for my web review for the week 2021-20.


Modern Javascript: Everything you missed over the last 10 years

Tags: tech, javascript

A nice list of somewhat recent features which made it to JavaScript.

https://turriate.com/articles/modern-javascript-everything-you-missed-over-10-years


Privacy activists are winning fights with tech giants. Why does victory feel hollow? | Evgeny Morozov | The Guardian

Tags: tech, privacy, democracy, innovation

There is so much more to criticize about tech giants than just privacy and fake news issues. It’s important to not mistake the tree for the forest. They’re also killing quite a lot of democratic and institurional innovations.

https://www.theguardian.com/commentisfree/2021/may/15/privacy-activists-fight-big-tech


5 steps to faster web fonts /// Iain Bean

Tags: tech, web, frontend, fonts

A few nice tips for dealing with fonts on the web.

https://iainbean.com/posts/2021/5-steps-to-faster-web-fonts/


Try This One Weird Trick Russian Hackers Hate – Krebs on Security

Tags: tech, security, funny

OK, now that’s a funny consequence of how authorities behave which are taken into account by criminals.

https://krebsonsecurity.com/2021/05/try-this-one-weird-trick-russian-hackers-hate/


Tutorial: breaking myths about AI fairness | Towards Data Science

Tags: tech, ai, machine-learning

Very nice tutorial, explores a good set of common biases. Also show that it’s not that simple to get rid of them.

https://towardsdatascience.com/tutorial-breaking-myths-about-ai-fairness-the-case-of-biased-automated-recruitment-9ee9b2ecc3a


Building Outer Wonders for Linux – Utopixel

Tags: tech, portability, linux, rust, elf

This is Rust focused but still, shows a good way to increase binary portability across distributions. I suspect a couple of things would be easier with elf-dissector even.

https://utopixel.games/en/blog/building-outer-wonders-for-linux/


freenode now belongs to Andrew Lee, and I’m leaving for a new network.

Tags: tech, irc, freenode

The Freenode network is very much in trouble… This is so sad, my account there dated back from the early days of my KDE involvement. Needless to say it felt a bit weird to let it go.

https://www.kline.sh/


Welcome to Libera Chat | Libera Chat

Tags: tech, irc, freenode

Hopefully, here is the safe haven for the people coming from Freenode. Time for a new account…

https://libera.chat/news/welcome-to-libera-chat


Game Engines Aren’t Just for Gaming Anymore | Hacker Noon

Tags: tech, 3d

Not that I needed to be convinced, but it’s now becoming clear 3D engines are getting out of games to become more pervasive.

https://hackernoon.com/game-engines-arent-just-for-gaming-anymore-nb2a34k0?source=rss


Software Estimation Is Hard. Do It Anyway. - Jacob Kaplan-Moss

Tags: tech, project-management, estimates

I got a slightly different view on the topic. To me there’s value in the process of estimating, the estimation itself less so. The process often helps you refine both your understanding of the technical domain but also of the business domain.

https://jacobian.org/2021/may/20/estimation/



Bye for now!

For a long time now, KDE's about dialogues (the ones you find in the help menus in many of our apps) have supported the ability to fetch a bunch of information about the authors of our applications from the KDE Store through the Open Collaboration Services API. It does this by sending a request to the store for each of the authors who have an ocs username defined, to get the information on user avatars, profile links, and a few other potentially interesting details.

Phoning Home

If you are paying attention, you are now squinting at the screen and going "wait, I saw that title up there, and it clearly says not phoning home, and this is phoning home". You are, of course, entirely correct, and while it certainly was never done with ill intent, it is hard to dispute the fact that it is, in fact, phoning home. As a result, we have been poking about with ways of fixing this, without dropping overly much of the functionality.

Some of those crazy author people what make Discover happen

You might now be thinking what functionality, and sure, it's seems like perhaps a small thing, but remember: KDE is a world-wide community of people who work on this massive pile of software, and the about dialogue is basically the first place where many people are likely to learn of that concept, if they decide to go and look. As such, we want to put our best face forward, and in this case what we want is to firstly not be causing any undue internet traffic (because nobody wants that), but also we want to literally put faces forward.

Not Phoning Home

As of a couple of weeks ago, the KDE Store has had a simple url which will give you a redirect to the avatar that you have set on there, at the scale you need of it, and that's what we're using now. You can use it yourself as well - there's a short introduction to it over here. You can also link directly to your profile in a similar manner, by just linking to store.kde.org/u/someusername - for example, mine is store.kde.org/u/leinir.

Oh look, authors what do money managementy things!

The result is two patches, which landed recently: One for Kirigami, and one for KXMLGui. All of this was originally spawned from a desire to reduce the complexity of KXMLGui itself, and specifically removing the requirement on Attica, which while certainly not heavy, was still doing an inordinate amount of work for an arguably small gain in this particular instance.

There is more to be done on this, mind you - if you read comments on the Kirigami patch, you will notice that one intention is to expand this avatarness to support things other than the store as well, and while i do have some ideas on the topic, if you've got some, don't hesitate to give me a poke! (not "why don't you just use gravatar", that's not the point here, any expansion of this needs to be generic, otherwise it doesn't make a huge deal of sense - the reason we're doing it this way is in part that the ocsUsername field is a part of KAboutData already, and it will Just Work(TM) for anybody who already uses that data structure).

Over To You?

Part of this work could arguably have been done before (specifically that not phoning home part, which from a user perspective is a checkbox which defaults to being off), but since this was originally based on removing the Attica requirement, frankly, this particular angle is something which i must confess, sadly, to have quite entirely missed.

And that, i guess, is the point here: It is staggeringly obvious in hindsight that this was totally a case of phoning home, and while it was never intended to be that, and to my knowledge was never used like that, it took someone pointing at it and going "yeah, this is doing a phoney homey thing" for me to go "yup, it clearly is, let's make that not happen". So that's what you can do here: Be that person that points out a blindingly obvious case of phoning home to someone who's just not noticed in a decade that that's what's happening, furthering KDE's goal of ensuring our software operates in a privacy conscious manner.

Finally, a direct question: Having to tick those boxes in each about dialogue is, arguably, a little far the other direction again, and having that tick apply to all about dialogues in our software would make that bit of life just a tiny bit simpler. Not a lot, arguably, but a little is also good, of course. The question, then, is this: Is it an acceptable tradeoff in privacy terms to let this tick box affect the about boxes in all our software, or should it be per-application? Personally i'm leaning toward it being acceptable, but i wanted to put it to the wider community before diving into that bit of the code.


The word of the day is: Care. Because we should, and we do :)

Plasma gets Prettier and more Blurred by the day!

Plasma gets Prettier and more Blurred by the day!