Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content Planet KDE
Planet KDE
Updated: 8 hours 40 min ago

KDE Goals – a year lost, a year gained

12 hours 39 min ago

The year 2020 was difficult in many ways, but it also was important for me: I joined KDE e.V. as a consultant in the role of Project Coordinator.

One of the main focuses of mine was supporting the KDE Goals initiative, which resulted in creating a formalized process.

As you might know (or read in the process), the KDE Goals are to be replaced roughly every two years.

This timebox was selected to balance keeping the Goals fresh, and letting the Goal Champions have enough time to work on the topics with the community.

Often, the goals have dedicated Sprints, where community members from all over the world meet up to work together – this not only greatly accelerates the work, but also lets the community create a stronger bond (and is a perfect opportunity to take group photos that the Promo team can use later

This week in KDE: the Plasma 5.21 beta is here!

Saturday 23rd of January 2021 07:01:00 AM

Well folks, you finally have a chance to test out Plasma 5.21, in beta form! Please do install it and find all the bugs we missed. Bug reports have already started pouring in, and we’ll fix them as fast as we can in the next month.

Partially-Formed @ Meeting C++ 2021 talk is now online

Thursday 21st of January 2021 09:16:40 AM

My talk “Partially-Formed Objects For Fun And Profit” from Meeting C++ 2020 is now online here: https://www.youtube.com/watch?v=9OQKZl7ha7g

From the abstract:

Lately, partially-formed states have gained some traction as the natural state of moved-from objects. Alexander Stepanov, in his landmark book Elements of Programming (EoP), defines them as a state in which the only valid operations are assignment and destruction. This state was, and continues to be, essential to high-performance code, and to the C++ guarantee of “don’t pay for what you don’t use”.

We will also show how developers that feel uneasy about the partially-formed state can avoid them at little to no cost, neither in code readability, nor performance, and use these examples to propose a new (or old) paradigm for API design: safe and unsafe functions (in the Sean Parent sense).

A longer version of the talk, in which I also cover the Bonus Slides, for which I didn’t have time in the Meeting C++ version, is available from the MUC++ YouTube channel: https://www.youtube.com/watch?v=HcSAIZafNZU

Efficient custom shapes in QtQuick with Rust

Wednesday 20th of January 2021 10:50:35 AM

One of the advantages of QWidgets when building a Qt application is the ability to build in a simple way custom widgets with the QPainter API. This gives the Qt developer almost total freedom to implement complex geometries for their widgets.

On the other hands, QML contains by default only rectangles. These rectangles can change the radius to create circles and rounded rectangles, but more complex shapes are more complicated.

The current state of custom geometry in QtQuick

Fortunally, the Qt API provides multiple ways to implement custom shapes, that depending on the needs might be enough.

There is the Canvas API using the same API as the canvas API on the web but in QML. It’s easy to use but very slow and I wouldn’t recommend it.

Instead of the Canvas API, from the QML side, there is the QtQuick Shapes module. This module allows creating more complex shapes directly from the QML with a straightforward declarative API. In many cases, this is good enough for the application developer but this module doesn’t offer a public C++ API.

If you need more controls, using C++ will be required to implement custom QQuickItem. Unfortunately drawing on the GPU using QQuickItem is more complex than the QPainter API. You can’t just use commands like drawRect, but will need to convert all your shapes in triangles first. This involves a lot of maths like it can be seen in the example from the official documentation or from the KDAB tutorial (Efficient custom shapes in Qt Quick).

A QPainer way is also available with QQuickPaintedItem, but it is slow because it renders your shape in a textured rectangle in the Scene Graph.

The Rusty way

What if we could transform arbitrary shapes into triangles? We would get a high level API but still get great performance. This process is called tessellation and there are a few libraries that implement it. For example in C++, we have Skia and CGAL. Unfortunatelly, both aren’t easy to use, so I decided to look at the Rust library ecosystem and in particular at Lyon, which was designed with performance and compliance to the SVG standard in mind since the goal is to use it in Servo in the future.

Lyon doesn’t have any C++ bindings but I got inspired by the recent blog post from Jonah and I need to say the experience of writing bindings was a breeze.

The first step was creating wrapper structs around the Lyon primitives. LyonPoint, LyonGeometry and LyonBuilder will later be directly usable from the C++ side.

#[cxx::bridge] mod ffi { pub struct LyonPoint { x: f32, y: f32, } pub struct LyonVector { x: f32, y: f32, } pub struct LyonGeometry { vertices: Vec<LyonPoint>, indices: Vec<u16>, } extern "Rust" { type LyonBuilder; fn new_builder() -> Box<LyonBuilder>; fn move_to(self: &mut LyonBuilder, point: &LyonPoint); fn line_to(self: &mut LyonBuilder, point: &LyonPoint); fn relative_move_to(self: &mut LyonBuilder, to: LyonVector); fn close(self: &mut LyonBuilder); fn quadratic_bezier_to(self: &mut LyonBuilder, ctrl: &LyonPoint, to: &LyonPoint); fn cubic_bezier_to(self: &mut LyonBuilder, ctrl1: &LyonPoint, ctrl2: &LyonPoint, to: &LyonPoint); fn build_fill(builder: Box<LyonBuilder>) -> LyonGeometry; fn build_stroke(builder: Box<LyonBuilder>) -> LyonGeometry; } }

We then need to define the methods we declared above. These are all trivial to implement since they are just wrapping the Lyon API.

use ffi:{LyonPoint, LyonVector, LyonGeometry}; // Create a wrapper arround Lyon svg path. This struct is opaque from // the C++ side so we won't be able to access the internal object, but // we still can call the methods on it. pub struct LyonBuilder { builder: WithSvg<Builder>, } // Implement wrapping methods impl LyonBuilder { fn close(&mut self) { self.builder.close(); } fn move_to(&mut self, to: &LyonPoint) { self.builder.move_to(point(to.x, to.y)); } fn line_to(&mut self, to: &LyonPoint) { self.builder.line_to(point(to.x, to.y)); } fn quadratic_bezier_to(&mut self, ctrl: &LyonPoint, to: &LyonPoint) { self.builder.quadratic_bezier_to(point(ctrl.x, ctrl.y), point(to.x, to.y)); } ... } // Lyon Builder constructor pub fn new_builder() -> Box<LyonBuilder> { return Box::new(LyonBuilder{ builder: Path::builder().with_svg() }) }

The next step was to add the build_fill that will transform the SVG path instructions into a set of vertices and indices. These vertices and indices will be directly available from the C++ side. This is extremely handy since this can be directly fed into the QSGGeometry painting method.

pub fn build_fill(builder: Box<LyonBuilder>) -> LyonGeometry { let mut buffers: VertexBuffers<Point, u16> = VertexBuffers::new(); { let mut vertex_builder = simple_builder(&mut buffers); // Create the tessellator. let mut tessellator = FillTessellator::new(); let path = builder.builder.build(); // Compute the tessellation. let result = tessellator.tessellate_path( &path, &FillOptions::tolerance(0.01), &mut vertex_builder ); assert!(result.is_ok()); } LyonGeometry { // convert_points transform lyon::point to our LyonPoint wrapper vertices: convert_points(buffers.vertices), indices: buffers.indices, } }

And we are almost done with the Rust side, we still need to create the cargo and corrosion configuration, but I won’t go into details in this post. You can look at how it was done in this pet project.

Using the generated bindings

To make it easy to store and manipulate the path, I create a simple abstraction to the various SVG path instructions.

#include <QList> #include <variant> #include <tessellation.rs.h> /// Move to the point without drawing a line. struct MoveTo { /// The destination. LyonPoint to; }; /// Drawe a line to a specific point. struct LineTo { /// The destination. LyonPoint to; }; /// Draw a cubic bezier curve to the point. struct CubicBezierTo { /// First control point. LyonPoint ctrl1; /// Second control point. LyonPoint ctrl2; /// The destination. LyonPoint to; }; /// Close a path. struct Close {}; /// SVG conform path commands using PathSection = std::variant<MoveTo, LineTo, CubicBezierTo, Close>; template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; }; template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>; /// The SVG path data. It contains a list of instruction (move to, line to, ...). using PathData = QList<PathSection>;

Now let finally use Lyon to generate the geometry primitives. This will need to be called every time the list of commands is updated. It’s using the command abstraction, I build previously, but this could directly call the LyonBuilder methods.

const auto commands << MoveTo { LyonPoint{0.0, 0.0} } << LineTo { LyonPoint{0.0, 40.0} } << LineTo { LyonPoint{40.0, 40.0} } << CubicBezierTo{ LyonPoint{70.0, 40.0}, LyonPoint{70.0, 0.0}, LyonPoint{ 50.0, 20.0} } << LineTo { LyonPoint{40.0, 0.0} } << Close {}; auto lyonBuilder = new_builder(); for (const auto &command: commands) { std::visit(overloaded { [&lyonBuilder](MoveTo moveTo) { lyonBuilder->move_to(moveTo.to); }, [&lyonBuilder](LineTo lineTo) { lyonBuilder->line_to(lineTo.to); }, [&lyonBuilder](CubicBezierTo cubicBezierTo) { lyonBuilder->cubic_bezier_to(cubicBezierTo.ctrl1, cubicBezierTo.ctrl2, cubicBezierTo.to); }, [&lyonBuilder](Close) { lyonBuilder->close(); }, }, command); } auto m_geometry = build_fill(std::move(lyonBuilder));

And finally here is our updatePaintNode method. It’s using the GL_TRIANGLES drawing mode and the vertices and indices are copied directly from the geometry Lyon gave us.

QSGNode *PathItem::updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *) { QSGGeometryNode *node = nullptr; QSGGeometry *geometry = nullptr; if (!oldNode) { node = new QSGGeometryNode; geometry = new QSGGeometry(QSGGeometry::defaultAttributes_Point2D(), m_geometry.vertices.size(), m_geometry.indices.size()); geometry->setIndexDataPattern(QSGGeometry::StaticPattern); geometry->setDrawingMode(GL_TRIANGLES); node->setGeometry(geometry); node->setFlag(QSGNode::OwnsGeometry); QSGFlatColorMaterial *material = new QSGFlatColorMaterial; material->setColor(QColor(255, 0, 0)); node->setMaterial(material); node->setFlag(QSGNode::OwnsMaterial); } else { node = static_cast<QSGGeometryNode *>(oldNode); geometry = node->geometry(); geometry->allocate(m_geometry.vertices.size(), m_geometry.indices.size()); } QSGGeometry::Point2D *points = geometry->vertexDataAsPoint2D(); std::size_t i = 0; for (const auto &vertice: m_geometry.vertices) { points[i].set(vertice.x, vertice.y); i++; } quint16* indices = geometry->indexDataAsUShort(); i = 0; for (const auto indice: m_geometry.indices) { indices[i] = indice; i++; } node->markDirty(QSGNode::DirtyGeometry); return node; }

It is only using Lyon SVG path rendering, but Lyon provides a lot more APIs. For example, there is an abstraction that allows to draw circle, ellipse, rounded rectangle and other basic geometric forms.

There is also the possibility to add custom attributes for texture coordinate or color coordinate. Depending on your need more part of the API could be wrapped and I might create a small library wrapping most of the API.

Custom shape in action

I used this technique in a new toy I’m building. I’m not sure where it is going, but I currently have this:

Getting your 3D ready for Qt 6

Wednesday 20th of January 2021 10:00:10 AM

As was previously discussed, since the 6.0.0 release of Qt, Qt 3D no longer ships as a pre-compiled module. If you need to use it on your projects, try out the new features, or just see your existing application is ready for the next chapter of Qt’s life, you need to compile Qt 3D from source.

In order to do this, you can do it the traditional way ([cq]make ...; make; make install) or use the Conan-based system that is being pioneered with the latest version of the MaintenanceTool.

Using Conan

The latest version of the MaintenanceTool (from the unified installers) will optionally install several things:

  • Conan, a package manager which can build C++ libraries and handle the dependencies
  • CMake, the meta-build system, which is required for Qt 6
  • Ninja, the lighting fast replacement for make and nmake

Additionally, you will need to select Qt 3D in the Additional libraries section so that the source code is available.

As mentioned above, these are optional. You need to find them and enable them in the MaintenanceTool’s UI.

 

Conan, being a package manager, is designed to handle all dependencies to make it easy to build libraries and applications. However, the way this is setup in the current packages installed by the MaintenanceTool is not complete.

Additional things you need for Conan

In particular, you need two other things:

  • You need to select the Qt Shader Tools module in the MaintenanceTool, if you intend to use the new RHI-based backend for Qt 3D. Without it, Qt 3D will build fine but only the original (and more feature rich) backend will be available.
  • Since Qt 3D is a Qt module, it has many of the similar requirements you need when building Qt itself. At the very least, you need a perl interpreter, so that the module header files can be generated. A full list of requirements for the various platforms is available here.

Once you have all the required bits, it’s time to open a console and run Conan. The process is platform-specific, as each platform has it’s own Conan profile. A complete example is available on the Qt wiki, but this is how it works on my mac where the Qt SDK is installed in /Users/Shared/Qt:

conan install qt3d/6.0.0@qt/final --build=missing -s build_type=Release -g cmake_paths -g=cmake -g deploy --profile=/Users/Shared/Qt/Tools/Conan/profiles/qt-6.0.0-macx-clang

and wait…it takes a while to build Qt 3D.

Notes:
  • conan, cmake and ninja need to be in your path. In particular, make sure the Qt provided version of Conan is found first, because…
  • the MaintenanceTool installs a custom version of Conan and write config files in the $HOME/.conan folder. This means, at least on multi-user systems, Conan will only properly work for the user who installed the Qt SDK, and that version is found before any platform-provided version.

 

Using QMake or CMake

Using the MaintenanceTool and Conan makes it easy to get the source and the required dependencies for building Qt 3D. As we saw in the aforementioned, there are still some rough edges. So, in particular, if you are familiar with building Qt modules already, you can just use the “old way”, i.e., download the source and use QMake, or now, CMake.

The packages for the released versions of Qt 3D (and other Additional modules) are available here.

QMake

Once extracted, you can do a shadow build of Qt 3D pretty easily (this has the same build requirements as above though, QtShaderTools module and perl interpreter).

tar zxf qt3d-everywhere-src-6.0.0.tar.xz cd qt3d-everywhere-src-6.0.0 mkdir build cd build /Users/Shared/Qt/6.0.0/clang_64/bin/qmake .. make make install

And, again, wait

Simple-Mail Qt library 2.3 released

Tuesday 19th of January 2021 09:50:31 PM

SimpleMail is a small Qt library for sending mails, this release makes sure it compiles fine with Qt6, and has some small issues fixed.

I thought this would give me a bit of work but was mostly changing CMakeLists.txt and including one header.

This week I’ll start working for KDAB

Cutelyst 2.14.2 and ASql 0.27 released!

Tuesday 19th of January 2021 06:08:14 PM

Cutelyst a Qt Web Framework and ASql an asyncronous SQL library for Qt got new releases.

The Cutelyst version 2.14.0 was made in December but was a silent one, I had some issues in production but weren’t related to Cutelyst, the .1 release included some contributions by Adriaan de Groot, I also did some changes for Qt 5.15 and Qt6 but for Qt6 a new major version is needed.

Besides a bunch of fixes, a major regression on the plaintext benchmarks got fixed, unfourtunately not in time for round 20, but thanks to ASql you will Cutelyst got a better scoring on SQL related benchmarks

ASql also got a bunch of bug fixes, but most importantly it’s now Qt6 ready.

And speaking of Qt6 Cutelyst port is also completed now, after I port most of my own apps I’ll do a v3 release which is compatible with both Qt5 and 6.

Have fun!

https://github.com/cutelyst/asql/releases/tag/v0.27.0

https://github.com/cutelyst/cutelyst/releases/tag/v2.14.2

Krita 4.4.2 Released

Tuesday 19th of January 2021 01:09:18 PM

Today, the Krita team has released Krita 4.4.2. With over 300 changes, this is mainly a bugfix release, though some key new features, too!

New Features Mesh Gradients

Sharaf Zaman’s Google Summer of Code project has landed in this release! Compatible with Inkscape, Krita now provides the second independent implementation of SVG Mesh Gradients. Mesh gradients are used on vector objects and can deliver really natural looking results:

Mesh Gradients

Mesh Transform

Mesh transforms will greatly speed up your concept by allowing complex transformations, such as the half-rounded grate on this window!

But the gradients are not the only mesh related feature! This release also sees the first iteration of the mesh-transform. Like the gradient mesh, the mesh transform consists of bezier patches that can be individually shaped to create precise transforms, especially useful for rounded objects. Not shown in the above screenshot: you can optionally show the handles of each bezier curve making up the mesh for even more precision and control!

We’re still tweaking this one, but currently the shortcuts are the following:

  1. Mesh node:
    – click+drag — move node
  2. Border node:
    – click+drag — move node
    – shift+click+drag — move whole row/column
    – ctrl+alt+click+drag — split/slide row/column
    – ctrl+alt+click+drag-away — remove split
  3. Control point:
    – click+drag — change control point symmetrically
    – shift+click+drag — change control point non-symmetrically;
    this action will create angular texture
    artifacts
  4. Node or Control:
    – ctrl+click — select multiple nodes
  5. Patch area:
    – click+drag — free patch deform
    – shift+click+drag — move whole mesh
  6. Empty area outside mesh:
    – click+drag — rotate mesh or selection
    – ctrl+click+drag — scale mesh or selection
    – shift+click+drag — move mesh or selection
Gradient Fill Layer and new Gradient Editor

The gradient fill layer and the new gradient editor in action.

Deif Lou added a new gradient fill layer type, this one will make it easy to quickly create a variety of gradients non-destructively. With it, he also made an important usability fix: Gradients in Krita could be either segment type, or stop type, with different features each, and different editors each. That could get quite annoying if you were working on a gradient, but you realized you had the wrong type! This is now fixed, as both gradient types can now be edited by the same editor, which also converts between the two.

Improved Halftone Filter

Deif Lou also created a new halftone filter. The old filter was slow and could not be used as a filter mask, and could only show dots.

The new halftone filter can do per-channel filtering, useful for vintag effects and maybe even printing!

The new filter can handle being applied as filter layer, per-channel filtering, and the pattern itself can be generated with any of the fill layer options, giving endless combinations.

Updated macOS integration plugins

Amyspark improved the quicklook plugin by adding thumbnailing support (needs macOS 10.15 or higher) and added metadata support for Spotlight.

A Paste Shape Style Action

A small feature that allows you to only paste the style of the copied vector shape onto other selected vector shapes. This feature can be found under the edit menu, or assigned a shortcut in the shortcut settings.

A Toolbar Button for Wraparound Mode

Originally, we had a shortcut, W, that enabled Krita’s Wraparound mode, one of the features Adobe copied this year for the next release of Photoshop.

But too many people pressed the shortcut by accident and were then confused and thought Krita had gone crazy… So we removed the shortcut, but now nobody could find it anymore. That’s why in this release, we have added a button to the toolbar that activates wraparound:

Please don’t press it by accident!

New brushes

There are also six new brushes by Ramon Miranda, meant to show off the new RGBA brush tip feature:

HiDPI Support


Agata Cacko improved HiDPI rendering (BUG:411118) of

  • Pixelart previews
  • Reference images
  • Comic manager pages
  • Image thumbnails in the last documents docker
  • Recent documents thumbnails
  • The Popup palette
  • Clipboard content in the new image dialog
  • The Color selectors
  • Gamut masks
  • Brush preset icon in the Brush preset editor
  • Layer thumbnails and icons
  • Resource choosers
  • Bundle icons
Bug Fixes File Handling
  • Files with names starting with a number are now autosaved correctly
  • Make it possible to load EXR files with non-ascii characters in the path
  • Disable making the background black for a semi-transparent EXR file (BUG:427720)
Painting
  • The PressureIn sensor now works correctly in combination with the Hue color expression (BUG:426234)
  • The speed smoothing algorithm no longer creates blobby lines (BUG:363364, 375360)
  • The colorsmudge brush now blends when there is a selection active (BUG:423851)
  • The brush outline no longer snaps when switching between two images with a different zoom level (BUG:427094)
Animation

Most animation work is going in the master branch, which will become Krita 5.0.

  • Onion skins are hidden when playing an animation (BUG:426246)
  • Warn the user when they are trying to run the ffmpeg download archive, instead of unpacking it
  • Fix converting an animated transparency mask to a paint layer (BUG:419223)
Usability
  • The default shortcuts for changing the mode in the selection tools have been removed: they are replaced by ctrl/shift/alt modifiers. The actions still exist, so you can configure single-key shortcuts in Krita’s shorcut settings dialog.
  • The magnetic selection tool now has buttons to confirm or discard a selection
  • An issue where moving a selection would jump was fixed (BUG:426949)
  • A Fit to Height zoom shortcut was added, patch by Jonathan Colman (BUG:410929)
  • The screentone generator’s defaults were improved
  • File layers that are dragged and dropped now have a proper name (patch by Jonathan Colman) (BUG:427235)
  • The popup palette now has a clear color history button (patch by Emilio Del Castillo)
  • The report bug dialog now provides the system information and usage logs in an easy to copy/paste manner
  • Blacklisted resources that contain a \ in the filename were ignored (BUG:421575)
  • Displays are shown by name in the color management settings page (BUG:412943)
  • Fix showing custom icons for user-defined templates (patch by Evan Thompson) (BUG:395894)
  • The fill layer dialog and seexpr widgets were polished
  • The x/y position spin boxes in the move tool options were fixed (BUG:420329, 423452)
  • Add default letter spacing for the text shape (patch by Lucid Sunlight)
  • Add support for user-installed color schemes (patch by Daniel)
  • All dialogs and message boxes are now correctly parented to the main window (patch by Daniel)
  • Make it possible to export groups as merged layers (patch by Dmitrij Antsevich)
  • Fix kerning handling in the text editor (patch by Lucid Sunlight)
  • Add support for color opacity in the text editor (patch by Lucid Sunlight) (BUG:342303)
  • Fix cropping the transform mask when moving the masked layer
  • Improve switching between SVG source and rich text editor (patch by Lucid Sunlight) (BUG:424213)
  • Fix issues with the brush outline getting stuck when the brush size is smaller than 0 (BUG:427751)
  • Improve the Python plugin importer so action files get imported correctly. (Patch by Rebecca Breu) (BUG:429262)
  • Fix tearing of patterns when scrolling in the resource chooser.
  • The rectangle and ellipse tool now have default shortcuts: Shift+R and Shift+J, respectively
  • Allow the Select Similar Color selection tool to pick from a set of layers, make work correctly with image bounds and handle transparent layers correctly. (BUG:428441)
  • Fix the isometric grid so it is drawn correctly
  • The outline selection tool was renamed to freehand selection tool (BUG:425894)
Filters
  • The bundled g’mic plugin is updated to 2.9.2 which contains a correct Boost-Fade filter (BUG:412617)
  • The gradient map filter was improved and made faster (patch by Deif Lou)
Stability and Performance
  • Fix a lot of memory leaks
  • Improve performance by removing a bottleneck when transforming internal colors to and from QColor
  • Fix a race condition in the Comics Manager plugin (BUG:426701)
  • Fix the fill layers updating too many times
  • Fix random crashes when changing screentone fill layer parameters (BUG:428014)
  • Fix a crash in the Square Gradient strategy (patch by Deif Lou)
  • Fix a crash when converting SVG source to rich text or back (patch by Lucid Sunlight)
  • Fix an assert when trying to liquify transform an empty layer (BUG:428685)
  • Fix an assert when creating a new layer from the visible layers while the active layer is hidden (BUG:428683)
  • Make the Select Similar selection tool multithreaded.
MacOS
  • On macOS, the Delete key (which is actually backspace) now deletes a selection. (BUG:425370)
Android
  • It’s now possible to open files from external sources, like a file manager, google drive or a download manager on Android
  • Add mimetype and pathpatter for .kra files
  • Make Krita a SingleTask application: this means that opening a file of a type supported by Krita will work properly even if Krita is already running.
  • Fix possible corruption when saving .kra or .ora files
  • Fix a crash on closing Krita (BUG:426092)
  • Fix “also save as KRA” (BUG:424612)
  • Handle mouse buttons state and touch events properly
  • Make resaving with different mime type work on Android (BUG:429056)
  • Make the theme background black for chromeos: this used to be pink, which looked ugly when resizing a window.
  • Fix flickering tiles when OpenGL is enabled (BUG:424347)
Download Windows

If you’re using the portable zip files, just open the zip file in Explorer and drag the folder somewhere convenient, then double-click on the krita icon in the folder. This will not impact an installed version of Krita, though it will share your settings and custom resources with your regular installed version of Krita. For reporting crashes, also get the debug symbols folder.

Linux

(If, for some reason, Firefox thinks it needs to load this as text: to download, right-click on the link.)

OSX

Note: the gmic-qt is not available on OSX.

Android

This time, the Android releases are made from the release tarball, so there are translations. We consider Krita on ChromeOS and Android still beta. There are many things that don’t work and other things that are impossible without a real keyboard.

Source code md5sum

For all downloads:

Support Krita

Krita is a free and open source project. Please consider supporting the project with donations or by buying training videos! With your support, we can keep the core team working on Krita full-time.

The post Krita 4.4.2 Released appeared first on Krita.

Environment Modules

Monday 18th of January 2021 08:59:07 PM
One of the forgotten tools

Environment Modules is one of those open source projects that I wish more people would know and use. I always wonder why tools like asdf don’t provide support for it instead of rolling their own implementation. So lets increase awareness.

The Environment Modules package provides for the dynamic modification of a user’s environment via modulefiles.

Environment Modules Homepage

So what does it do? Here is a small example:

~ $ type ansible bash: type: ansible: not found ~ $ module avail -l ansible/ - Package/Alias -----------------------.- Versions --------.- Last mod. ------- /home/mjansen/local/etc/modules: ansible/2.8.15 2.8 2020/10/28 18:43:05 ansible/2.9.13 2.9 2020/10/28 18:43:15 ansible/2.10.1 2.10:default 2020/10/28 18:42:56 ~ $ module load ansible/2.9.13 ~ $ ansible --version ansible 2.9.13 config file = None configured module search path = ['/home/mjansen/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules'] ansible python module location = /home/mjansen/local/opt/ansible/2.9.13/lib64/python3.8/site-packages/ansible executable location = /home/mjansen/local/opt/ansible/2.9.13/bin/ansible python version = 3.8.6 (default, Nov 09 2020, 12:09:06) [GCC] ~ $ type ansible ansible is hashed (/home/mjansen/local/opt/ansible/2.9.13/bin/ansible) ~ $ module unload ansible ~ $ type ansible bash: type: ansible: not found

So in short environment modules allow you to alter your shell session dynamically by

  • Altering the content of environment variables
  • Setting/Removing aliases
  • Create functions in the users environment
  • There is more in the modulefile man page.

Modulefiles are actually tcl scripts. It is a slightly weird (imo) looking scripting language. Tcl and environment modules are available forever. They are from the 1990s.

The ansible script above looks like this:

#%Module1.0##################################################################### ## ## ANSIBLE VERSION ## proc ModulesHelp { } { global version puts stderr "\tActivates ansible v$version [ARA]" } set home $::env(HOME) set version 2.9.13 set root $home/local/opt/ansible/$version set ansible_callback_plugins [exec $root/bin/python3 -m ara.setup.callback_plugins] module-whatis "Ansible V$version" conflict ansible append-path PATH $root/bin setenv ANSIBLE_CALLBACK_PLUGINS $ansible_callback_plugins

So why should you care. As a hypothetical developer you probably need to install different versions of libraries and tools to check your programs against or with. Like different Qt Versions or compiler. Most developer I know then proceed to use shell scripts they source to deal with that. This does not allow easy unloading and switching. Utilizing environment modules gives you a much more pleasant experience. My list currently looks like this:

- Package/Alias -----------------------.- Versions --------.- Last mod. ------- /home/mjansen/local/etc/modules: ansible/2.8.15 2.8 2020/10/28 18:43:05 ansible/2.9.13 2.9 2020/10/28 18:43:15 ansible/2.10.1 2.10:default 2020/10/28 18:42:56 catt 2019/08/26 14:58:23 editor/vim 2020/10/26 19:39:10 elixir_escripts 2020/11/11 05:29:32 elm/0.19.1-3 0.19:0.19.1:default 2020/03/31 22:24:21 go/1.13.6 2020/01/21 16:06:16 gopath 2020/01/21 16:16:09 groovy/2.4.7 2019/08/26 14:58:23 groovy/2.5.7 2019/08/26 14:58:23 home_install 2020/02/23 16:20:05 hugo/0.76.5 2020/10/28 18:46:11 hugo/0.80.0 2021/01/09 21:07:52 java/jdk1.8.0_172 2019/08/26 14:58:23 jupyter 2019/08/26 14:58:23 maven/3.3.9 2019/08/26 14:58:23 minishift 2020/03/29 16:29:17 novisual 2019/08/26 14:58:23 reclass/1.4.1 2020/01/27 14:27:20 reclass/git 2020/12/20 19:51:34 usr_local 2020/01/29 13:36:42 vit 2020/01/15 17:01:25 zeppelin/0.9.0-preview2 2020/10/29 16:42:13

Environment modules also has the concept of sessions which allows you to save and load different configurations. Either in a central location (eg. ~/.module) or to a file specified on the command line.

~ $ module save homepage ~ $ module savelist Named collection list: 1) homepage ~ $ module saveshow homepage ------------------------------------------------------------------- /home/mjansen/.module/homepage: module use --append /home/mjansen/local/etc/modules module load editor module load gopath module load go module load hugo -------------------------------------------------------------------

Modulefiles can even specify conflicts, so you don’t load two different versions of a library or program. They can also specify requirements, so you don’t forget to load a python version before loading ansible.

If you want to try environment modules one word of warning. In opensuse after installing environment modules it is not active. I guess the same applies to other distros. Shell initialization files for additional packages are a sore spot in most distros. You have to activate it manually in your shell initialization file (eg. bashrc).

# ACTIVATE ENVIRONMENT MODULES # {{{2 ############################################################################### case "$0" in -sh|sh|*/sh) modules_shell=sh ;; -ksh|ksh|*/ksh) modules_shell=ksh ;; -zsh|zsh|*/zsh) modules_shell=zsh ;; -bash|bash|*/bash) modules_shell=bash ;; esac source /usr/share/Modules/init/$modules_shell test -r /usr/share/Modules/init/{$modules_shell}_completion && source /usr/share/Modules/init/{$modules_shell}_completion

KDE e.V. board meeting January 2021 (2)

Sunday 17th of January 2021 11:00:00 PM
KDE e.V. Board up close

Madness! 8-hour BBB calls all weekend for the KDE e.V. board. On the social front, I won at Skribbli, and workshopped the FLA, wrote a bunch of mail to keep people informed about what is going on, read even more email, listened to bits and pieces, but – as can be seen in the photo, vaguely – I still haven’t gotten around to shaving off my scary sideburns.

The “workshop” part of these meetings is kind of important because it means spending time and effort on topics that I would usually leave dangling at the bottom of my priority list. Most of the time I prefer to write code, over writing bureaucratic documents. But I have reached inbox zero for my KDE stuff, which is a big achievement.

There were musical highlights, in fuzzy and blue and the Dutch version pluizig en blauw.

Results will trickle out over the next few weeks, for instance when the board pushes some updates to the e.V. website with new forms and documents.

Season of KDE 2021

Sunday 17th of January 2021 02:06:03 AM

Hello, it has been a while, today I bring good news!

First a bit of background, I am Jean Lima Andrade, a second year student of IFBA (Federal institute of Bahia), last year I have participated on SoK 2020 and GSoC 2020. You may know me from my previous posts.

On this Season of KDE, I will be adding support for audio annotation on marK. This year, Pranav, a fellow SoK student, will also add video annotation support, I will be mentored by Caio Jordão Carvalho alongside Tomaz Canabrava. I look forward to work with all of them.

That is it, see you on the next post ; )

Systemd Applet Release

Saturday 16th of January 2021 09:16:30 PM
Systemd Applet Bugfix Release

Given no one seems to be interested in working on the applet (boo) I decided to tackle the bug myself. Apparently the fact it worked previously was the result of happenstance.

The systemd manager processes only send out signals after at least one process told them to do so. It seems that some process did that on my computer before but no more. From the doc:

Subscribe() enables most bus signals to be sent out. Clients which are interested in signals need to call this function. Signals are only sent out if at least one client invoked this function. Unsubscribe() undoes the signal subscription that Subscribe() implements. It is not necessary to invoke Unsubscribe() as clients are tracked. Signals are no longer sent out as soon as all clients which previously asked for Subscribe() either closed the bus connection or invoked Unsubscribe().

After adding the call now the applet notices state changes for units on the session manager too.

Next step is proper licensing. Getting it reuse compatible.

Then moving it over to kde infrastructure.

KDE OSM Indoor Map Demo App

Saturday 16th of January 2021 10:00:00 AM

Last year KDE Itinerary got an indoor map view for airports and train stations, using a specialized map renderer and using raw OSM data as source. Improving that by contributing to upstream OSM data as well as our MapCSS styles now got a bit easier.

KOSMIndoorMap Demo App

The component used by KDE Itinerary for this, KOSMIndoorMap, is a library and as such not really useful without being embedded in an application. Having to create dummy itineraries covering all locations you want to check so you can look at the map is however very inconvenient e.g. when working on OSM data upstream.

To address this one of KOSMIndoorMap’s test programs has been expanded to a little stand-alone demo/test app, and more importantly, packaged for KDE’s nightly Flatpak and Android builds.

Flatpak:

flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo flatpak remote-add --if-not-exists kdeapps --from https://distribute.kde.org/kdeapps.flatpakrepo flatpak install kdeapps org.kde.kosmindoormap

Android:

Note that this is not meant as a user-facing application at this point, and as such misses things like translations and contains a number of features only useful for contributors. It doesn’t even have all the features and controls yet the indoor map integration in KDE Itinerary has at this point.

KOSMIndoorMap standalone demo app offering different means of selecting a location.

Should somebody be interested in creating a generally useful indoor map app, that could certainly be done on top of KOSMIndoorMap (and we should talk :) ), but that’s currently not the scope here.

Reviewing OSM Data

The most important use-case for now is reviewing (and improving) OSM data. The crucial difference between regular (outdoor) maps and indoor maps is the floor level topology. Whether that data is correct is hard to judge on a map renderer that doesn’t split floors.

In OSM, floor levels are modeled using the level tag, anything not on the ground floor should have that. In the most simple case the value is just an integer number, and the most common issue is that this is missing on a few elements.

Side-by-side comparison of two floor levels showing railway tracks on the wrong level at Brussels South station.

Slightly more elaborate are elements connecting multiple floor levels, such as stairs, elevators or escalators. For those the level tag should contain a range or semi-colon separated list of floors. In our indoor map renderer this results in the ability to change floors by clicking on the corresponding element. This information being incomplete is also common, resulting in stairs only shown on a single floor for example.

Some stairs in Munich central station being non-interactive due to only being assigned to a single level.

After identifying and fixing such issues in the OSM data you should see the new data in the app within a week or two, as it propagates through the server-side and local caches.

Improving MapCSS Styling

When editing and improving our MapCSS map styles, the stand-alone app is equally useful. The app allows you to load an external MapCSS stylesheet, as well as reload one previously opened, so you get immediate feedback of your changes.

This does work fine on Linux, on Android this is a bit more complicated due to the file system sandboxing mechanisms. So I’d expect problems there when using stylesheets spread over multiple files (for which we need access to the entire directory). KDE Itinerary works around that in development mode with allowing to “upload” changed stylesheets into its internal storage space, but that’s still missing in the stand alone app.

What you get on both platforms though is the “diagnostic” style, showing the raw geometry of all elements, and the ability to show all OSM tags in the element information dialog (enable “Debug Info Model”).

Testing and Feedback

A third use-case of course is general testing of the indoor map renderer and its higher-level functions like properly identifying train station platforms or airport gates, or the matching of OSM elevator/escalator data with the corresponding realtime status information.

There’s a workboard for identified issues, proposed extensions or any other feedback.

Season Of KDE - The Beginning

Saturday 16th of January 2021 07:31:30 AM

Hello KDE Community I am Manav Sethi an engineering student from India and I got selected for Sok this year .

I will be working on creating an app for the Promo Team which will be used to post to multiple social media platforms at once. Since the Promo team Members spend time posting the same thing on multiple platforms this will definitely help in increasing their efficiency.

My mentor for this project would be Paul Brown who will be helping me deliver the Promo team's vision of this app.

P.S.: For Fans of the Popular American Sitcom The Office Yes I am creating kind of a clone of wuph.com

This week in KDE: text reflow in Konsole!

Saturday 16th of January 2021 05:36:39 AM

This week a huge new feature landed in Konsole: it now reflows the text when you resize the window! This feature can be turned off if you don’t like it, but comes on by default. It works really well. Thanks very much to Carlos Alves and Tomaz Canabrava for this work! It will be released in Konsole 21.04.

Other New Features

Gwenview now lets you optionally use a solid black color while in full screen view (Antonio Prcela, Gwenview 21.04):

Dolphin now lets you configure whether newly-opened tabs go at the end of the tab bar, or after the current tab (Anthony Fieroni, Dolphin 21.04):

Ark now supports ARJ archives (Natsumi Higa, Ark 21.04)

Bugfixes & Performance Improvements

Spectacle now lets you change the default screenshot file format when using a non-English language (Nicolas Fella, Spectacle 20.12.2)

Elisa no longer crashes when you enqueue a song accessed using the filesystem browser view (Matthieu Gallien, Elisa 20.12.2)

Adding radio streams in Elisa now works again (Sven Marquardt, Elisa 20.12.2)

Elisa’s “Show current track” button once again works (me: Nate Graham, Elisa 20.12.2)

The “Apply” button of Elisa’s settings window now activates and deactivates at the correct times (Matthieu Gallien, Elisa 21.04)

When using a vertical panel, the date displayed below the clock no longer sometimes becomes huge (Marco Martin, Plasma 5.21)

Plasma no longer freezes when an app sends many notifications in quick succession (Kai Uwe Broulik, Plasma 5.21)

Fixed various issues with Breeze theme context menu borders sometimes being invisible or pure black (David Redondo, Plasma 5.21)

The Global Menu applet now updates properly when focus is changed to or from a GTK app (David Edmundson, Plasma 5.21)

When pulling up the virtual keyboard on the login or lock screen, the password field now remains focused, so the characters you type no longer disappear into the void without manually re-focusing it first (me: Nate Graham, Plasma 5.21)

After enabling any calendar plugins in the Digital Clock, the calendar panel now appears instantly, rather than requiring Plasma to be restarted first (Nicolas Fella, Plasma 5.21)

Discover’s sidebar header no longer sometimes overlaps the contents after resizing the window (Marco Martin, Plasma 5.21)

Fixed a case where a newly-created panel could be placed on the wrong screen in a multi-screen setup (Xaver Hugl, Plasma 5.21)

KRunner once again parses and interprets hexadecimal input correctly (Alexander Lohnau, Plasma 5.21)

Country code labels in System Settings’ Keyboard page are now legible when using a light color scheme with a Dark Plasma theme (or the reverse) (me: Nate Graham, Plasma 5.21)

Aborting a change in System Setting’ Users page by canceling the authentication dialog no longer causes the changes to be applied anyway (Nicolas Fella, Plasma 5.21)

KDE Connect no longer sometimes crashes when it gets spammed with notifications (Nicolas Fella, Frameworks 5.79)

Kirigami icons in apps now consume a bit less memory, which will appreciably reduce memory usage for apps that have a lot of icons (David Edmundson, Frameworks 5.79)

User Interface Improvements

Dolphin now lets you decompress multiple archive files at a time via the context menu item (Elvis Angelaccio, Ark 20.12.2)

Ark’s preview window now closes when you hit the default “close window” shortcut (typically Ctrl+W) (Méven Car, Ark 21.04)

Ctrl+clicking on a Places panel item in Dolphin now opens it in a new tab (Kai Uwe Broulik, Dolphin 21.04)

System Settings’ Login Screen (SDDM) page has been rewritten which fixes a bunch of bugs and makes it look nicer and more consistent (David Redondo, Plasma 5.21):

It’s now possible to drag QML-based apps from empty areas of their headers and backgrounds, just like QWidgets-based apps (Marco Martin, Frameworks 5.79 with Plasma 5.21)

Plasma’s “microphone is being used” indicator now tells you which microphone is being used in its tooltip (Kai Uwe Broulik, Plasma 5.21)

System Settings’ Default Applications page now supports the “Highlight default settings” feature (Cyril Rossi, Plasma 5.21)

The Global Menu applet now respects Fitts’ law by allowing you to slide your cursor from one menu to another one on the row of pixels that is touching the screen edge (Jan Blackquill, Plasma 5.21)

System Settings’ Splash Screen page now lives in the Appearance category (me: Nate Graham, Plasma 5.21):

The “Get new Plasma Widgets” dialog now uses the much nicer new-style version (Alexander Lohnau, Plasma 5.21):

KDE apps no longer show Docker volumes in their Places panels (Méven Car, Frameworks 5.79)

How You Can Help

Have a look at https://community.kde.org/Get_Involved to discover ways to be part of a project that really matters. Each contributor makes a huge difference in KDE; you are not a number or a cog in a machine! You don’t have to already be a programmer, either. I wasn’t when I got started. Try it, you’ll like it! We don’t bite!

Finally, consider making a tax-deductible donation to the KDE e.V. foundation.

KDE e.V. board meeting January 2021

Friday 15th of January 2021 11:00:00 PM

A few times per year, the board of KDE e.V. gets together for a board meeting. While we also meet once a week for an hour to keep track of what is happening within the organization, the longer meetings are when big tasks are undertaken and the dusty corners are tidied up.

KDE e.V. Board sits down for a meeting

Of course, “getting-together” is not a viable activity right now. Much as we would like to sit around a table with shared coffee and late-night beer and walks, right now that is not possible. So, using KDE’s Big Blue Button infrastructure, our meeting is online.

The KDE BBB is there for the whole of the KDE community. There are some (sub-)groups that use it occasionally, some regularly. Allyson organizes smaller events on it, and of course we have an online Akademy to look forward to.

During the meeting we mix boring-administrative, high-level-strategic, social-and-silly activities. For instance, I have “update the address in the FLA” on my list, but there is also a budget to start writing (led by Eike), some of our ongoing projects to evaluate, and albatrosses like “can we possibly accept cryptocurrencies without angering the tax office?”

This weekend is booked solid, but we figure there will be a board ask-me-anything or fireside chat sometime soon again – and of course there is always the KDE community mailing list if there are things that the KDE community needs to discuss, feel free to ping us there as well.

Season Of KDE 2021

Friday 15th of January 2021 02:19:42 PM

Hello, KDE! I’m Pranav, a first year bachelor’s student from India. Although I have worked on KDE projects previously during Google Code-in 2018, I had to take a break for university enterance exams. However, now that I am an uni student, I hope to start contributing more and more.

During this SoK, I will be working on adding video annotation support to marK, and Caio Jordão Carvalho will be mentoring me. Although marK only supports text and image annotation at the moment, Jean(a fellow SoK participant) and I will add video and audio annotation support respectively, and I’m looking forward to working with him.

I remember talking to Caio about this project, when we met during the Google Code-in 2018 Prize trip, and I thought it was really cool. So, needless to say, I am excited to work on it. I will be progress updates as I work on the project. Until then, happy coding!

Season Of KDE 2021

Friday 15th of January 2021 01:26:33 PM

Hello!!, I am Rohan. I am participating in this year’s Season Of KDE. I will be working with the KDE promo team in building an automated data collection and analytics platform. I will be under the mentorship of Paul Brown. Excited about the broad range of the project. That’s all for now.

Hopefully, the next time I write things will be more interesting.

Improve your software product delivery process performance using metrics (II)

Friday 15th of January 2021 12:30:00 AM

This is the second article of the series. Please read the first post before this one.

During the previous article I explained the process to follow, using the simplest possible model to describe a software product delivery process, to measure and improve its performance, following a data driven improvement kata as a way to promote a continuous improvement culture .

Despite providing extremely valuable information, once we have gone through the described process for a few iterations, the limitations of such a simple model will become evident. We will need to add complexity into our model, getting closer to the real software product delivery process.

Add complexity to approach reality.

If you have a clear map of your real delivery process, you can skip this step. If you do not, the first thing I recommend is to run a value stream workshop to discover and describe your delivery process. Visualizing it as a group is a great exercise, not just for those involved in the workshop, but also for the rest of the organiza­tion. If you are not able to draw the flow of the code end to end, identifying what happens where and who is responsible for what, trying to measure the performance of the process is often pointless.

How should the model be enriched?

For our purpose, we do not need a great level of detail as outcome of the value stream workshop, just enough to create your new model. Let’s assume for now that one of the outcomes of such workshop is a drawing like the one below, which I took from an exercise for an automotive platform. Only the “green criti­cal path” is shown here. I hope you get an idea of what is needed.

Based on this diagram, you can see clearly that the delivery process can be divided in three or four stages. Try to do it in three, again, for simplicity. For this example I will divide it in four since, in automotive, the validation/verification stage is rele­vant in terms of effort, complexity, throughput and specially stability.

So our richer model can be expressed in the following way:

This new model is a better approximation to our real delivery process.

Mathematical construct and quantitative analysis

Once we have described our system using a richer model, the question is, do we need to change our mathematical construct?

As you can guess, the answer is no, we do not. We just need to enrich it. The construct used to characterize the simplified model would have been very limited if now we would have needed to modify it.

Again, Steve Smith provides in his book “Measuring continuous Delivery” what we need to extend the metrics. The overall idea is to use the same metrics and measures for the entire process (as we did with the simpler model) and for each stage (corresponding to this new model). This is essentially the case for any linear process, like the one we created. S. Smith refers to these “extensions” of the metrics and measures as indicators.

It becomes now harder to define the events to extract the data sets from since the data probably needs to be extracted from different tools. I recommend to invest time in describing these events, how the data sets are extracted from the affected tools, how to convert such data into the right units… You will also need to describe accurately which events determine the beginning and end of each stage. All this effort will allow you to iterate in the process creating more complex models.

The methodology to measu­re, process, plot and analyze the different data-sets will be analogous to the one described in the first post of this series. The only difference is that now it should be done for each stage, in addition to the overall process.

Qualitative analysis

It is easy now to realize why we tried to keep our scale simple. The number of combi­nations we need to work with increa­ses now. The scenarios for each stage are consistent with those described for the previous (simpler) model, so the qualitative analysis done for both models complement each other.

The definition of the scenarios can be personalized and adapted to your needs. Since you will also use those scenarios as a communication tool, make sure they are described in away that resonates to your workforce. Reduce their number to those that make sense to you and ignore the others.

You should execute the same qualitative analysis for each stage of the delivery process to describe in simple words the scenario that better describes the current performance of your delivery process as well as the target scenario. Please remember that the goal is to improve the performance of the overall process not to optimize any specific stage. If an improvement done in a specific stage does not have a positive impact in the overall process, you need to question the consolidation of such improvement.

Data Driven Improvement Kata

This step will require changes. Now that our system model is more complex, the methodology to improve performance of the delivery process will need to consider the company organi­zational structure as well as the cycles in which the business, product and development teams operate.

At scale, these katas cannot be structured in a single cycle, but in several ones. The book “Leading The Transformation. Applying Agile and DevOps principles at scale” by Gary Gruver and Tommy Mouser provides an idea of how to approach this continuous improvement process for larger organizations.

I suggest to consider two cycles whenever you can. In my example (very academic, to explain the process) I have consided three: business cycle, product cycle and experiments cycle.

Please check the references (at the end of the first article) to learn more about improvement kata. I will make some considerations about the above example for those of you less familiar with continuous improvement methodologies:

  • The overall idea is to synchronize the three cycles.
  • Business cycles are usually a year long. I would structure the business iterations in quarters.
  • Define the business goals for the product and relate them both, qualitatively / qualitatively with the metrics / scenarios.
  • Define the current scenario and the target scenario for the current quarter. Be concise.
  • Define the most suitable cycles for your product. Bare in mind that some effort in analysis, coordination and communication with the workforce will be required on each iteration so too short cycles might bring unnecessary overhead.
  • If the development teams work in weekly sprints, I would start with monthly iterations for the product level. If engineering teams work with two weeks sprints, then consider iterations of six weeks at product level.
  • As described in the previous article for the simpler model, I will use the boards to explain how the iterations are defined.

The first board correspond to the business cycle, the second one to the product and the third one to the technical experiments to be performed by development teams. Click the picture to enlarge and read the advises.

Summary

In this second article, we have enriched our model introducing more complexity (four stages). We saw how the mathematical construct should be extended to characterize each stage, which allow us to get a finer grain information, increasing the accuracy of our analysis. We have seen that Throughput and Stability remain useful as key metrics, as expected.

We have also discovered that, as it happe­ned with our quantitative analysis, the qualitative one is essentially an extension of the one introduced in our previous article for our simpler model. We have modified our approach to continuous improvement adapting the data driven improvement kata to a more complex environment. The proposed example. covers, in my view, large organiza­tions. Such data driven improvement kata has been summarized in three boards, one per level: business, product and technical.

Conclusion

These two articles represent a modest attempt to summarize and structure in 5 basic steps the process that an organization should go through to improve its delivery process performance at scale using Throughput and Stability as guiding lights.

Obviously writing about this topic is easier than implementing it so I am looking forward to read about your own experience and how it contradicts, modify, complements or support the described methodology and advises.

The new beginnings- Season Of KDE

Thursday 14th of January 2021 05:36:26 PM

Hello KDE community! I am Sai Moukthik Konduru, an undergrad from India. This pandemic gave me a chance to explore my interest in programming, and it has been a roller-coaster ride, to say the least. Recently I got to know about the concept of Open-source projects. The idea of collaborating and learning from the best and brightest minds across the globe has pumped me up so much that I started looking for organizations to work with. I found the KDE community thanks to a youtube video and got to know about the Season of KDE. I was not sure if I was good enough to be a part of Sok. But thanks to Devin Lin (who helped me make my first open-source contribution and is also my mentor for SoK), I am confident that I can complete this project as long as there is this huge community behind me.

A Brief description of my project:

At present, Plasma Mobile is a budding project, and there is a need for quality apps to make it bloom. Productivity apps are important for any platform, be it desktop or mobile. To make the productivity suite of plasma mobile better by a notch, we need a simple yet effective app and, foKus is aiming to be that. foKus will be a task management app that will help the user stay organized and manage their day-to-day tasks, thus making them productive. Many of the current to-do apps miss the right balance between simplicity and features and end up being counter-productive. The goal of foKus is to be the perfect productivity app, and below are the features that will make it the best. Features of the app: 

  • Simple yet beautiful UI. 
  • Ability to quickly enter the task. 
  • Ability to reorder the tasks. 
  • Ability to prioritize the tasks. 
  • Ability to set a reminder for the tasks. 
  • Ability to time the completed tasks to keep track of our performance. 
  • Have a “focus mode” which helps the user to focus on the tasks by locking out the unproductive apps(like social media). 
  • Cloud Sync, to access the list from any platform and from anywhere.

As the duration of SoK is less than three months, it is not possible to develop the perfect app. By the end of SoK, foKus will have the essential functionalities (the first few features from the above list) with a simple and elegant design. As the KDE community is active and ever-growing, we can keep on adding more and more features to the app and make it better every day. There is a lot of potential in this app, and through SoK, I plan to build a strong foundation for it to grow.

I have learned so much just by making a single contribution, and I can’t even imagine how much I can learn by participating in SoK.

More in Tux Machines

Who's new

  • trendoceangd
  • Onzarwadabun
  • kmcmillan
  • Marius Nestor
  • johnwalsh