We’re already on Week 3 of the coding period of Google Summer of Code! As a reminder, I’m adding Python support to a few KDE Frameworks. During the first two weeks I added support for KWidgetsAddons, and it’s now almost finished except for two widgets whose bindings aren’t generated properly and don’t compile.

I also wrote (with the help of my mentor Carl) the necessary CMake code to build the library. That part is probably going to end (hopefully) in extra-cmake-modules so it can be used by anyone easily. The plan is to eventually submit each of the bindings to their repository so it’s easier to keep the C++ libraries in sync with their Python bindings.

This week I will be adding some examples for KWidgetAddons now that it’s on a usable status. If you want to see how it’s going, you can take a look at the code.

Do you find yourself opening up the same tabs in your terminal and running the same commands every day? Have you wanted to make this easier, say, by clicking a desktop icon or running a short command?

Recently, I saw a question along these lines in the KDE support room on Matrix. Someone wanted to have Konsole automatically open some tabs and run specific commands when it's started. Since I've done this kind of thing, for personal and professional environments, I thought I'd share. You too can avoid doing the same manual terminal setup day after day, and just get to what you're working on.

Here in Part 1, I'll outline how to open tabs with different profiles and run commands in them. Next week, in Part 2, I'll share how to set up layouts (a.k.a. split panes) and run commands in those. You can combine these techniques to make your setup truly flexible. Using aliases, functions and scripts, you can bring up a complex layout with one command or button click.

Inspiration

I have a motto: If I have to do the exact same thing more than twice (on a computer), I should probably script / automate it. It's an up front time investment that saves me a lot of manual tedium later.

My inspiration for scripting terminal layouts came from iTerm2's customization abilities. After a few years of using it on a work-provided MacBook Pro, I was spoiled. It's truly nice how easy it is to create profiles and save splits in the GUI. You can then tweak their configurations using any text editor. When I searched for how to do this with Linux terminals, I found quite a few people were also looking for an "iTerm2 equivalent for Linux".

Goal: Launch a Konsole window with tabs which run commands

💡 Note For more detailed instructions on using Konsole, please see the output of konsole --help and take a look at the Konsole Handbook

We'll start with that request from Matrix: having Konsole create tabs and run commands in them when it starts. Here are the steps I used to accomplish this. Feel free to use this as inspiration and adapt for your own needs.

Use case: Quickly set up a working environment that I use daily to save time every day. There will be a couple of tabs connected to different remote hosts, one that changes to a notes directory, and one running a system monitor.

Here's an overview of the steps:

• Create a Konsole profile which will run a command and optionally use another color theme
• Create a tab layout file to launch Konsole with which will open a tab with that profile
• Create a profile with a different command for an additional tab, and then identify commands for a couple of the other tabs
• Update the tab layout file to launch Konsole with all the desired tabs

Now let's get into the details.

Create the first Konsole profile

Making custom profiles for different hosts are where my adventures in customizing Konsole began.

Use case: I would like to automatically connect to my hosted VPS in a tab with a specific color theme.

Reasoning: Running commands using a theme is quicker and easier than typing by hand (especially as they get more complex). With a custom color scheme, I can see at a glance which tab has my server session vs. any other system. This helps me avoid typing commands for my server into another system and vice-versa.

💡 Note Profiles are stored as plain text files in /.local/share/konsole/. Profile names are cAsE senSiTive. Since profile files are plain text, you can create, edit, and delete them with scripts. That is beyond the scope of this post.

The first step is to set up a custom profile with a custom color theme, a custom tab title format, and a command.

I'm using "eternal terminal" (et) for its ability to reconnect, rather than ssh to connect to the VPS. I also have an entry for the host in .ssh/config

In Settings -> Manage Profiles - New I created a profile named VPS. The following are the options I changed. Others were left as-is ("hostname" is a stand-in for the actual VPS hostname):

Name: VPS
Command: et VPS
Tab title format: %n hostname
Tab Color: I chose a color
Appearance - Color scheme & font: I chose a different color scheme

Now that I have a custom profile, I can use it with a new tab in Konsole. When I go to File -> New Tab and click "VPS", the tab will open with the new profile, and the command will run to connect to the server.

You can use Konsole's command line options in the following way to have it launch with a tab using a profile.

konsole --new-tab --profile VPS

This command can be used with an alias, function, script, Windows batch file, desktop shortcut or whatever you prefer.

There's another way to launch Konsole which is better for opening multiple tabs. It uses a "tabs configuration file".

Create a tabs configuration file

💡 Note I have found this to be unreliable if any tab uses ssh or et There's an open bug report for this. Until this is resolved, you may have better luck with a shell script that opens multiple tabs, I'll add information below.

Now I'll create a tabs configuration file with the VPS profile in it.

Each line in this file describes a tab for Konsole to open. The format is detailed in the command line options documentation. I keep these in ~/konsole_layouts/, keep yours in whatever directory works for you. I'll save this file as "vps-tabs".

Each line must have at least a profile or a command field. It can have both, and there are other options as well.
Do not specify a command on a line for a tab if you also use a profile which itself has a command. This may lead to unexpected behavior.

If you only need to run a command in a tab, you can just use the command field. You combine a command with a profile (that has no command) if you want to customize the tab further.

This is what will go in the file for now for my first tab:

title: VPS ;; profile: VPS

The command below will start Konsole using this file. (Change file path to point to the file on your system). Opening Konsole in this way can also be done with an alias, script etc.

konsole --hold --tabs-from-file ~/konsole_layouts/vps-tabs

Notice that I'm using --hold which tells Konsole to keep tabs open even after their command has exited. This will help debugging any problems that might arise (unless the window crashes entirely or fails to load). Once things are set up and running smoothly, you don't need to use --hold, if you prefer.

Create additional profiles

Use case: At the start of the day, I want to automatically open tabs which connect to both servers I need to work with. I want an additional tab open to my notes directory and another one running a system monitor.

Time to add an additional profile to Konsole:

• Server2 - this will use ssh to connect to a second server and use a profile for a different color theme

I won't create profiles for the system monitor tab or the Notes tab. I'll run those commands directly from the tab configuration file.

Update the tabs file with additional tab definitions

At this point, I'll add lines to the tabs configuration file I created.

• A tab for the Server2 profile.
• A tab which changes to a notes directory, and uses the Sand profile with colors I prefer for them.
• A tab for the system monitor which runs the btm command and uses another profile with yet another color scheme.

The file now looks like this:

title: VPS ;; profile: VPS
title: SysAdminNotes ;; workdir: ~/Nextcloud/Notes/SysAdmin ;; profile: Sand
title: Server2 ;; profile: Server2
title: NavyBlue ;; command: btm ;; profile: NavyBlue

And now, when I run konsole --hold --tabs-from-file ~/konsole_layouts/vps-tabs, Konsole launches with all the tabs I need.

Bonus: Run commands after connecting to a remote host

It's possible with both ssh and et to run commands on a remote host after connection. For instance, I could update the command in my VPS profile like so:

Name: VPS
Command: et VPS -c 'sudo apt update && apt list --upgradable; exec /bin/zsh'
Tab title format: %n hostname
Tab Color: I chose a color
Appearance - Color scheme & font: I chose a different color scheme

The command not only connects to my VPS, it also displays a list of any available updates, and stays connected to the host. Note the exec /bin/zsh at the end. This will keep an interactive terminal open after other commands are run.

With ssh, to run a command on a remote host while staying connected, the command is slightly different:

ssh -t VPS 'sudo apt update && apt list --upgradable; zsh'

But what if I need to connect to a jumphost before the remote host and I still want to run a command after I connect?

This can be done with either SSH or Eternal Terminal. For SSH, the process is relatively easy, and plenty of sites online provide instructions. Eternal Terminal, on the other hand, is a bit more tricky.

It took some research and experimentation to get this working with Eternal Terminal, so here it is ("jumphost" is a placeholder for the actual hostname of the jumphost).

Command=et jumphost -c "ssh -t remotehost 'cd /some/directory && . ../some_script && cd ../another-directory; exec /bin/zsh'"

Alternative to using a tabs file: a shell script or function

If you have difficulties with using a tabs configuration file, you can use a shell script (or function) that takes advantage of the command line options Konsole has. For instance, using the -e flag we can have tabs run commands:

#!/usr/bin/env bash
konsole --new-tab -e echo This is tab 1 &
konsole --new-tab -e echo This is tab 2 &
konsole --new-tab -e echo This is tab 3 &
konsole --new-tab -e echo This is tab 4 &

You can combine commands with profiles as well:

#!/usr/bin/env bash
konsole --new-tab --profile VPS &
konsole --new-tab --profile Sand --workdir: ~/Nextcloud/Notes/SysAdmin &
konsole --new-tab --profile Server2 &
konsole --new-tab --profile NavyBlue -e btm &

Explore the Konsole docs and experiment!

Known issues

• Launching Konsole with --tabs-from-file will open an extra tab in addition to the ones from the configuration file. This has an open bug report.
• Sometimes, with --tabs-from-file, the new Konsole window immediately disappears. This may be related to ssh/et being in a command. I filed a bug report for that.
• If using a tabs configuration file, or a script: only use Eternal Terminal with one tab. Trying to use it with more than one tab will result in et core dumping in one of them.

Stallman was right; in the wake of Microsoft’s announcement of its much-maligned Recall feature and widespread public backlash to the terms and conditions for Adobe Creative Cloud products, it’s clear that trust in big tech and the software it produces is rapidly eroding. Under the circumstances, it’s no surprise that Free/Libre and Open Source Software (FLOSS) is seeing an uptick in interest from the public at large. So as ever more average users consider “switching to Linux,” it strikes me that while there exist tomes on the technical aspects, there seems to be much less written on the shift in thinking that is part and parcel of every experienced and well-adjusted FLOSS user. So if you’re making the switch or know someone who is, here’s some advice to make the most of the transition.

Welcome #

First of all: welcome to GNU/Linux! You’ve chosen the operating system that powers bullet trains, the world’s fastest supercomputers, U.S.A. air traffic control, CERN’s Large Hadron Collider, and Google, Amazon, and Microsoft’s cloud services, used by NASA, the People’s Liberation Army, the Turkish government, whitehouse.gov, the U.S.A. Department of Defense, France’s national police force, ministry of agriculture, and parliament, Iceland’s public schools, the Dutch Police Internet Research and Investigation Network, Burlington Coat Factory, Peugeot, DreamWorks Animation, the Chicago Mercantile Exchange, the London Stock Exchange, the New York Stock Exchange, and Stephen Fry.

As you’ve no doubt inferred by now, GNU/Linux users span from your everyday cat-video viewer to large institutions and organizations where operating system reliability and performance mean the difference between life and death. No matter where you are on this spectrum, with a little humility, open-mindedness, and perseverance, I promise that you can find your self every bit as happily at-home with GNU/Linux as you were with whatever OS you’ve been using up to this point. This may mean giving up a long-trusted piece of software for something new and different, but for many new users the most hard-won battle is a change in mentality.

You’re not a power-user anymore #

I’ve heard it said that the most “computer literate” people often find it especially arduous to adjust to GNU/Linux. I’ve been there; it’s a frightening thing to go from the person family, friends, and neighbors call to help with problems with any device that has so much as an LED on it to feeling like that clueless relative with a dozen toolbars installed on their outdated version of Internet Explorer. The reality is that while you’ve gotten very good at navigating the operating system that you’ve been using for the past twenty years, very little of that knowledge is useful in GNU/Linux. This is something you’re going to have to accept early on: no matter what distro you choose, it’s going to be different to Windows or MacOS in very fundamental ways.

This means that, no matter your mastery of Windows keyboard shortcuts, or how convoluted your AutoHotkey config may be, it’s going to take you some time to grasp the basics. Beyond that, the bar to become a GNU/Linux power-user is much, much higher than it is on proprietary operating systems. In case you’re feeling intimidated, know that this comes with some serious advantages. GNU/Linux systems come with a practically limitless potential for mastery, efficiency, and customization. In time, you’ll be able to customize your GUI to your exact specifications, automate system maintenance, and knock out common tasks with a speed you wouldn’t have thought possible on your old OS.

Embrace the new #

Switching to GNU/Linux is, in some ways, much more convenient than switching from, say, MacOS to Windows. Chiefly, most distros can be configured to run a wide range of software built for MacOS, Windows, or Android with minimal fuss. That said, I strongly encourage new users to explore FLOSS alternatives built on and for GNU/Linux. FLOSS projects often get a bad rap among users of proprietary operating systems because while a piece of software may run on these systems, the experience is rarely as good as it is on the system is was designed for: usually, GNU/Linux. FLOSS mainstays such as LibreOffice, Krita, Inkscape, Scribus, Kdenlive, and Ardour are at their best on GNU/Linux in terms of appearance, performance, and features. There are professionals of every stripe who do their work with an exclusively FLOSS toolset, from graphic design to video editing, audio production, data analytics, and more. If they can do it, so can you! Don’t let the one piece of proprietary software that just won’t work put you off of your new operating system when there’s a whole new ecosystem of incredible software to explore.

New users of FLOSS projects often complain that the user interface or workflow of the tool they’re trying is “unintuitive.” Occasionally, these complaints hit on an area that genuinely could use some improvement, but more often, new users are simply expressing frustration that the workflow of a FLOSS project is different from what they are used to. These applications are not mere clones of their proprietary counterparts; they are projects in their own right, with unique goals, ideals, features, and workflows. Getting through a work project a little more slowly at first is not necessarily a flaw in the tool, it likely just means that you need a bit more practice. In time, you’ll come to learn and appreciate killer features that go above and beyond the capabilities of software produced by even the largest tech companies.

As a GNU/Linux user, you’re part of a community #

When you switch to GNU/Linux, you’re not a customer any more. FLOSS projects are largely build by communities of volunteers who work on what they find interesting or important for their own reasons. There’s no support line to call, no one to complain to if something breaks, and no one is losing anything by you choosing not to use their software. If you need help, or if you want to help make a FLOSS project better, you’re going to have to engage with the wider community. Every project has a forum, a Matrix or IRC channel, or some other means of connecting users and developers. If you have a problem you can’t solve on your own, these are the places to go to get help. Sign up and make a good faith effort to learn the rules and etiquette of the community, and chances are someone will be more than willing to help you find a solution out of sheer civic-mindedness.

There is likewise a great deal of pleasure and satisfaction to be gained by returning that kindness: by being an active participator in the communities you join, you’ll help others overcome the stumbling blocks you once faced and foster connections with others who share your interests. Beyond the community alone, there is something wonderful about using software that you’ve helped shape; contributing well written bug reports, monetary donations, writing documentation, or testing new releases makes a direct positive impact on the tools you rely on each day. It’s one thing to use FLOSS projects for reasons of ethics, privacy, or mere utility, but seeing a page of documentation you’ve written go live for anyone in the world to learn from, seeing a bug you reported vanish after an update, a theme you created get added to a game, or experiencing your feature request given form in a release really draws you in. You’re no longer at the mercy of some large tech company who only cares about profit; you’re part of a community that cares about people, ideas, and making its software better, more efficient, more usable, and more useful for everyone.

The FLOSS mindset #

To distill what I’ve said above: Things are going to be different, and you may feel disempowered and frustrated for a while until you catch up again. The solution to this, beyond simple patience, is to embrace the fact that by using FLOSS projects, you become a part of the process of making them. Join the community with respect and humility, allow yourself to receive help and kindness from others, and you’ll begin to once again remember how it feels to earn your skills. In time, you’ll be the one offering help, you’ll dance circles around any Windows power-user, and you’ll be using tools that you’ve helped make better. Again I say: welcome. With these small shifts in your thinking, you’re going to be in for a good time.

If you're looking for an isolated and straightforward way to start contributing to KDE, you're in the right place. At KDE, we use fuzzing via oss-fuzz to try to ensure our libraries are robust against broken inputs. Here's how you can help us in this essential task.

What is Fuzzing?

Fuzzing involves feeding "random" [1] data into our code to check its robustness against invalid or unexpected inputs. This is crucial for ensuring the security and stability of applications that process data without direct user control.

Why is Fuzzing Important?

Imagine receiving an image via email, saving it to your disk, and opening it in Dolphin. This will make Dolphin create a thumbnail of the image. If the image is corrupted and our image plugin code isn't robust, the best-case scenario is that Dolphin crashes. In the worst case, it could lead to a security breach. Hence, fuzzing helps prevent such vulnerabilities.

How You Can Help:

We need to update the build of KDE libraries in oss-fuzz to use Qt6. This task could be challenging because it involves static compilation and ensuring the correct flags are passed for all compilation units.

Steps to Contribute:

1. Start with karchive Project
   

   • Download oss-fuzz and go into the karchive subfolder.
   • Update the Dockerfile to download Qt from the dev branch and KDE Frameworks from the master branch.

2. Update build.sh Script:

   • Modify the build.sh script to compile Qt6 (this will be harder since it involves moving from qmake to cmake) and KDE Frameworks 6.

3. Check karchive_fuzzer.cc:

   • This file might need updates, but they should be relatively easy.
   • At the top of karchive_fuzzer.cc, you'll find a comment with the three commands that oss-fuzz runs. Use these to test the image building, fuzzer building, and running processes.

Need Help?

If you have questions or need assistance, please contact me at aacid@kde.org or ping me on Matrix at @tsdgeos:kde.org

Note:

[1] Smart fuzzing engines don't generate purely random data. They use semi-random and semi-smart techniques to efficiently find issues in the code.

Today marks the release of  KDE Stopmotion 0.8.7!

About Stopmotion

Stopmotion is a Free Open Source application to create stop-motion animations. It helps you capture and edit the frames of your animation and export them as a single file.

Direct capture from webcams, MiniDV cameras, and DSLR cameras. It offers onion-skinning, import images from disk, and time lapse photography. Stopmotion supports multiple scenes, frame editing, basic sound track, animation playback at different frame rates, and GIMP integration for image. Movies can be exported to a file and to Cinelerra frame lists.

Technically, it is a C++ / Qt application with optional dependencies to camera capture libraries.

Changes in release 0.8.7

This release comes with no new features, but improvements to the project itself.

Changes

• The project is now officially called to KDE Stopmotion. The former name Linux Stopmotion is no longer used.
• Support for qmake has been removed. Use CMake instead.

Features

• Port serialization to libarchive. libtar is abandoned. (thanks to Bastian Germann)

Bugfixes

• The .sto files miss the tar trailer. (#16, thanks to Bastian Germann for providing a fix)

Improvements

• Use pkg-config to find dependencies vorbisfile and xml2 (thanks to Barak Pearlmutter)
• Remove code that relies on deprecations in Qt 5; this is a preparation to move to Qt 6.
  

Future plans

• Transition from Qt 5 to version 6. I am stuck with my port as QAudioDeviceInfo that was dropped in Qt 6. I need some help to port Stopmotion to the new way to handle audio with Qt 6 / Qt Mulimedia.
• We should integrate better to KDE's tech stack: Internationalization, using KDE libraries, update and reformat documentation.
  

Get involved!

If you are interested, give Stopmotion a try. Reach out to our mailing list stopmotion@kde.org or have a look into our project. Share your ideas or get involved!

I’m a heavy user of Firefox profiles. Apart from using different profiles for different activities, I also have a few extra profiles that all run in the Default activity.

This means that I need to have different icons shown in Plasma’s panel in order to be able to easily differentiate which profile a window belongs to.

Sure, I use the tasks applet which shows the window title instead of the icon-only one (I prefer usability to minimalism), but still, it isn’t enough as sometimes the active tab in a Firefox window might not have the most informative title.

Plasma seems to rely on the application name and the window class when choosing the icon it will show in the panel. Which means that, by default, all Firefox instances end up having the same icon.

Fortunately, Firefox allows you to specify the window class it should use through command line arguments.

firefox -P ProfileName --class WindowClassName

And, to connect a launcher to a specific window class, you just need to add the following line to the .desktop file:

StartupWMClass=WindowClassName

So, in order to have a nicely supported Firefox profile, you can create a launcher with a desktop file similar to the following:

[Desktop entry]
Exec=firefox -P SocialSites --class FirefoxSocialSites
Icon=user-available-symbolic
StartupWMClass=FirefoxSocialSites

It also works with Firefox derivatives such as Librewolf (which can be seen in the screenshot above) and others.

Wayland

For Wayland users, a comment by John Kizer might be useful:

On Wayland, I’ve ended up just using KWin Window Rules (based on a substring of the window title, and setting the desktop file name) in combination with .desktop files that launch Firefox to the site in question and have the desired icon associated.

EDIT: And another approach for Wayland by Christoph Martin:

There’s no need for messing around with window rules - at least not for Firefox.

If you use the –main flag instead of the –class flag for the Firefox invocation in your .desktop file, you should get the desired effect - at least in the Icons-Only Task Manager. Note that StartupWMClass still needs to match the value of the –main flag.

The above works on my machine, that is under Plasma 6.0.5 on the Fedora 40 KDE spin.

Credit: https://superuser.com/a/1784867

G2 posted some fun logos for Kate on reddit.

I think they are nice and flashy and well suited if you want to show your appreciation for Kate and like that art style and a good addition to our awesome icon and mascot.

Static Version

Animated Version

Licensing

G2 licensed these files under the CC BY-NC-SA 4.0. Feel free to share the stuff with this license and credit for G2.

Comments?

A matching thread for this can be found here on r/KDE.

Let’s go for my web review for the week 2024-23.

Alice in Wonderland: Simple Tasks Showing Complete Reasoning Breakdown in State-Of-the-Art Large Language Models

Tags: tech, ai, gpt, machine-learning, safety, research

Another cruel reminder that basic reasoning is not to be expected from LLMs. Here is a quote from the conclusion of the paper which makes it clear:

“We think that observations made in our study should serve as strong reminder that current SOTA LLMs are not capable of sound, consistent reasoning, as shown here by their breakdown on even such a simple task as the presented AIW problem, and enabling such reasoning is still subject of basic research. This should be also a strong warning against overblown claims for such models beyond being basic research artifacts to serve as problem solvers in various real world settings, which are often made by different commercial entities in attempt to position their models as a strong mature product for end-users. […] Observed breakdown of basic reasoning capabilities, coupled with such public claims (which are also based on standardized benchmarks), present an inherent safety problem. Models with insufficient basic reasoning are inherently unsafe, as they will produce wrong decisions in various important scenarios that do require intact reasoning.”

https://arxiv.org/abs/2406.02061

A critique of Cara.app: the ‘No AI’ Instagram and Artstation copycat child. - David Revoy

Tags: tech, social-media, art, criticism

Interesting critique of this new platform… it’s the beginning of the hype cycle but will probably exhibit the same decay phenomenon than other platforms.

https://www.davidrevoy.com/article1032/a-critique-of-caraapp-the-no-ai-instagram-and-artstation-copycat-child

Why are vulnerabilities out of control in 2024? – Open Source Security

Tags: tech, foss, security, data, data-science

The more releases out there the more vulnerabilities are (and could be) discovered. Some actions are necessary to get things under control properly.

https://opensourcesecurity.io/2024/06/03/why-are-vulnerabilities-out-of-control-in-2024/

Engineering for Slow Internet

Tags: tech, networking, reliability

A good reminder of everything which might go wrong when connectivity is bad. Most tools let you down in such a case.

https://brr.fyi/posts/engineering-for-slow-internet

Why do CPUs have multiple cache levels? | The ryg blog

Tags: tech, hardware, cpu

Very nice explanation and metaphors on how CPUs cache levels work.

https://fgiesen.wordpress.com/2016/08/07/why-do-cpus-have-multiple-cache-levels/

BenchExec: A Framework for Reliable Benchmarking and Resource Measurement

Tags: tech, benchmarking, tools

Looks like an interesting benchmarking tool. To keep an eye on.

https://github.com/sosy-lab/benchexec

TIL #099 – order values of dictionary by iterable of keys with operator.itemgetter | mathspp

Tags: tech, programming, python

Definitely a nice Python trick. Fairly elegant, I’ll try to remember it.

https://mathspp.com/blog/til/order-values-of-dictionary-by-iterable-of-keys-with-operator.itemgetter

Message authentication codes for safer distributed transactions

Tags: tech, filesystem, distributed, safety, cryptography

Interesting use of cryptography without a security concern. It’s more about safety and ensuring something wasn’t missed by mistake.

https://mazzo.li/posts/mac-distributed-tx.html

The state of Vulkan apps in 2024

Tags: tech, 3d, vulkan, portability

The difficult path for Vulkan. The data obviously is biased since it includes games and most of them are still targeting Windows and so DirectX. I’d be curious to see something similar excluding games (and so focusing on medical, industrial etc.).

https://www.carette.xyz/posts/state_of_vulkan_2024/

How I learned Vulkan and wrote a small game engine with it

Tags: tech, 3d, game, vulkan

Interesting dive into the experience of writing a small Vulkan engine (almost) from scratch.

https://edw.is/learning-vulkan/

How to Build Engineering Strategy

Tags: tech, management, strategy, vision

Packed with useful information. Clearly some things I’m eager to test in there.

https://blog.practicalengineering.management/how-to-build-engineering-strategy-42e464018177

xkcd: Earth Temperature Timeline

Tags: science, history, data-visualization

So yes, the climate changed before… now slowly scroll until the end to appreciate how brutal it is this time.

https://xkcd.com/1732/

Bye for now!

Edit 2024-07-13: applications for this position are closed.

KDE e.V., the non-profit organization supporting the KDE community, is looking for a proactive contractor to support and coordinate the KDE Goals process. The role involves providing project management, community engagement, event planning, and other needed services to help drive the success of KDE Goals. Please see the job ad for more details about this contracting opportunity.

We are looking forward to your application.

Every 2 to 3 years KDE selects 3 goals that the whole community can focus on for the coming years. For the past 2 years we have focused on improving the accessibility of our applications, worked to make our software more sustainable and automated and improved a lot of processes to make developing software in KDE smoother. To learn more about these goals check out the KDE Goals page. We will wrap up these goals at Akademy in Würzburg later this year.

It is now time to figure out what the next goals should be. We are starting this today by opening the floor for proposals. This means you (yes you!) can campaign for something you and others want to work on over the next 2 years and rally the KDE community behind it. To give you some inspiration you can have a look at the complete list of goals we’ve had in previous years.

How does it work?

You (and a small group of others) can submit a proposal by opening a ticket on this Phabricator board. Copy the template into a new ticket and explain your idea. The template gives you a few hints to help you create a meaningful proposal. This process is open until July 5th. (On July 5th we will start the refinement stage, where others can further help you improve the proposal.)

Some things to keep in mind

• The process is explicitly open to proposals from people who are not yet KDE contributors.
• The process is explicitly open to everyone, not just developers.
• We expect the champions of the goal to be the champions, not the only ones working on the goal. At the same time they will need to put in significant work to rally people around their goal.

What is different compared to previous editions?

We are tweaking the process a bit this time. If you’re familiar with the process from previous years here are the most important changes:

• We are moving from an individual champion to a small team of champions. Each goal should have someone who can carry the vision of the goal forward, someone who can technically steer it and someone to promote it. Other setups are possible where it makes sense for the particular goal but a goal needs a small team. Don’t have a team yet? That’s ok. Submit a proposal and say what you need. We will try to help find others to join.
• We are focusing the champion role more on driving the goal forward through others and less by doing all the work themselves.
• We will work with the goal champions on fundraising for specific projects that support their goal.

What’s the timeline?

• Starting today until July 5th: Propose goals and find team
• July 5th to August 15th: Refine proposals together with the community (identify issues, remove blockers, sharpen the proposal, …)
• August 15th to 31st: Voting on the proposed goals by active KDE contributors
• September 6/7th: Selected goals are announced at Akademy

Still got questions?

If you still have questions you can ask them in various places:

• In the office hour on June 14th at 7PM Berlin time. You can find the time in your timezone here. The meeting will happen on BigBlueButton.
• The KDE Goals matrix channel.
• The KDE Community mailing list.
• Reaching out to me directly.