Language Selection

English French German Italian Portuguese Spanish

Kde Planet

Syndicate content Planet KDE
Planet KDE | English
Updated: 9 hours 17 min ago

On conflating Reviews and Comments

10 hours 15 min ago

Sometimes, when you look at distribution systems with build-in user interaction, you will see that system-designers haven’t really thought about what the user interaction actually is.

More specifically, it seems that they haven’t really thought about who the interactions their system allows are for. Is the text field for readers to give feedback to authors, or to other readers? Or is it just for the website itself to know?

An example of this would be YouTube. YouTube’s user-interactions consist of a convoluted subscription system, a like/dislike vote bar and comments. The convoluted subscription system is for the watcher? But then the author of a video also gets informed in detail how much growth and whatever they have, so maybe it’s for the author? The like/dislike system is… no clue for who it is, it doesn’t show up in search results or elsewhere. But apparently people clicking on the thing is good for the recommendation algorithm??? Then there’s the comments system, which… is for the audience to talk to the author? Or is it for the audience to talk to the rest of the audience? Some certainly treat it as such?

Compare this to for example, the comment and like functionality on a blog. It’s clear that this is intended to communicate something to the blog writer, maybe to other people, but like, everyone involved knows the blog writer sees it. Similarly, on a link aggregator, it’s clear the discussion is for the other readers of the aggregator, and the likes/dislikes are about recommending the link to other readers of the aggregator.

Places like fanfiction.net have a function called ‘reviews’, but a cursory investigation reveals that people just treat them as comment sections. AO3, similarly, has a like and comment functionality which understand these to be for the reader to the author. It also has a recommendation system for readers to recommend to other readers, which may include a description, that authors are not informed about.

A lot of the big software stores are especially weird in this regard. They have a review section, with a rating, but then the author of the software can comment on the review. So, is the review for other users, or is it for the author of the software?

The thing is, the meaning of a review changes significantly whether it exists for other users or for the author. If you rate something for other users, it is clearly a way to indicate recommendation. If you rate something for the author… it’s a grade, basically, isn’t it? Like high-school?

And it gets even more confusing, some of these stores will list the top rated entries, but, like, what does top-rated mean? Is it the report card grade, or is it an indication of how popular the entry is? It’s no wonder that algorithms like Youtube’s and Reddit’s have just given up on using the values themselves, and instead use engagement. Which is leads to a pretty clear meaning: People are emotioned enough to go into motion to press that like button. A top ten of stuff that makes people really upset, if you will. And I am hardly the first person to state that this isn’t very good for everyone’s sanity.

The reason I am worrying about this is because I have noticed that the KDE store, and by extension, KNewStuff, conflate comments and reviews. Which seems to be due to a hack (a review being a comment with a rating attached), but I think we might be able to conceive of solutions…

Distribute the reviews

So, the first problem is that the reason we expect reviews in content distribution systems is because readers and users should be able to find something that appeals to them. Reviews then are another user’s opinion of a thing, intended for potential users. By putting reviews into a spot where the reviewer knows the subject’s author can read it, even comment on it, a dilemma appears: Are they supposed to prioritize being polite, or are they supposed to prioritize honesty? It’s possible to be both, but that requires a lot of nuance and energy to accomplish. So in effect, this is a usability problem where we are expecting the user to be really skilled.

Similarly, by putting the reviews in a place where the reviewer knows the subject’s author can read and comment on them, the author is also put into a precarious position. If a review is really bad or insulting, should the author respond nicely (reviewer might be having a bad day?) or flag it? And what if they don’t respond at all? Why are we making all these people so potentially anxious?

Let’s distribute the reviews. The basics here would be that if someone wants to review a thing, we help them write something on their blog, or microblog, or maybe one of the 5 chat protocols KDE supports, mailinglist?

For aggregating, we could use something like webmention (with the vouch extension, because otherwise mods will go nuts), or special API to let the user link their review to the thing (if a user doesn’t want to link the review, that’s their choice).

The store doesn’t necessarily need to be the aggregator, we can also just look at the social feeds someone has, such as rss feeds or other social media feeds (I don’t quite know the logistics of this yet, let someone store a review for later, maybe?). This has the side-effect people will more likely get the recommendations from folks they know, making them more effective.

We also don’t really need to worry about authors not reading reviews, because they do that regardless, the masochists, but we should make it possible for an author to ignore a review.

I’m still not quite sure about the ratings themselves either. Like, we can disambiguate it by stating that it’s a rate of recommendation, not a rate or ‘whether or not this is the best thing to exist’. But another thing to think about is whether or not it applies to all things equally. Like, with software, a 5-star rating could imply that it did everything the reviewer needed from it, and a 2-star rating that it did not. But for a story this is much harder to determine, and I’ve been wondering if a different kind of rating system, like one based on a limited set of emoji? A horror story is going to be rated 2 by someone who hates to be afraid, and 5 by someone who loves the feeling, but both will likely rate it with ‘

digiKam: GSoC 2021 Week 2

12 hours 45 min ago

Hi!

Another week has just passed and I have new things to share. This week was more maintenance work and getting ready before we try to build digiKam with Qt6.

In the last week, I ported a lot of code to Qt 5.15, however we need to maintain compatibility with at least Qt 5.12 LTS. I wrote several pre-processor checks and macros to maintain the required compatibilty. These are some commits:

Next, digiKam had some code that created QSet objects from a QList with QList::toSet() and some calls to QSet::fromList() which are deprecated. Qt now enforces the use of QSet constructor with the container iterators. This merge request implements this. Thanks to Alexander Lohnau for pointing out that this patch had the issue of container detachment because of non const containers. Prior to this, I had worked only with STL containers and had assumed the iterators to be valid in Qt containers as well. There is always something new to learn everyday in C++.

Now, I’m modernizing the code and using STL algorithms wherever I can to replace for loops. cppcheck report of the master branch has a lot of issues. I have to resolve

  • qSortCalled
  • qrandCalled
  • qsrandCalled
  • useStlAlgorithm

There is a work-in-progress merge request for this.

Having worked for a few weeks on this project, I can already see the evolution of Qt5 to Qt6. All the deprecations make sense we are moving towards a better Qt. The tasks are intense but I’ve learned a lot.

Thanks for reading! See y’all next week.

Akademy 2021 – II

Sunday 20th of June 2021 06:36:59 AM

I was able to see a few more presentations than anticipated. The most inspiring was the one given by Patricia Aas I Can’t Work Like This. Based on a fictive story (with a lot of real background) she explained the Cynefin framework No, this is not a new UI or Qt based framework. The idea of the Cynefin framework is that it offers decision-makers a “sense of place” from which to view their perceptions. Unfortunately, I missed Nicolas Fella’s What’s cooking for KDE Frameworks 6. Coincidentally, I was preparing dinner at the time. This also cost me the first minutes of Dan Vratil’s C++ Coroutines and Qt. I compensated that by watching Dave Edmundson’s talk about Wayland for Qt application developers. Until yesterday, I thought Qt will abstract everything away from the application and we don’t have to do anything within KMyMoney, but now I know better. Thanks Dave. Guess I have to start playing with Wayland then in the near future just to avoid surprises in the future.

Today I am planning to see the following presentations/talks:

  1. Plasma: Work from Home Edition – As a somewhat new remote worker this seems interesting
  2. Growing a KDE Video Community – I watched one or two of Niccolò’s video and always wanted to have some for KMyMoney
  3. Porting user applications to Qt6 – Guess what?
  4. Developing products that break out of our bubble(s) – I am always surprised how many people use our software. Let’s see what Neofytos has to say.
  5. The Art of Logging – A thing that is sleeping in the back of my head for KMyMoney for a long time
  6. How we can solve the personal data problem – KMyMoney is all about personal data: your finances!
  7. Journey from a Farm Girl to Holograms – Hopefully, I will not be sleeping by then …

Week 2 on Kalendar (GSoC 2021)

Sunday 20th of June 2021 12:04:41 AM

Last week’s merge request was manually merged by Carl, and now Kalendar has a (kinda) working event editor sheet! Some bits work and others don’t:

Working:

  • Title, location and description addition to event
  •  Event date and time setting
  •  Reminder and attendee attachment to event

Super not working right now:

  • Event recurrence

So… mostly there!

New week, new merge request

This week’s MR involved a big refactor of the linkage between the front-end of the reminder and attendee addition UI and the back-end stuff going on.

All this stuff now happens with models, and changes in each of the fields gets added to the models. This means that anything that you see in the UI should directly reflect whatever is present in the actual event — you won’t see a reminder and attendee that isn’t actually in the event. The benefits of having a single source of truth!

The UI for each attendee’s details has also changed, and it now allows you to select the attendee’s status (i.e. have they RSVPed?) and it also lets you request an RSVP from the attendee.

Also, Kalendar’s repo has been moved into the PIM namespace on Invent, so now you can more easily find it

Akademy 2021 - Day 2

Saturday 19th of June 2021 10:01:40 PM
Talks, Lightning Talks & Panels

First thing in the morning, Aleix Pol, president of KDE, introduced the event at and explained how Akademy 2021 was still "special" because we could still not meet in person.

Aleix then introduced the first keynote speaker of the event: Patricia Aas, co-founder of TurtleSec and a C++ developer and trainer. In her talk, Patricia explored bugs, types of bugs, how to deal with the secondary problems bugs create.

Then Aleix was back with his own talk, in which he told us about KDE's "All about the apps" goal. The goal encourages community members to develop, improve and help distribute KDE apps. Thism it turns out, is especially important for new KDE environments, such as Plasma Mobile! He explained how the goal is going and encouraged people to join the effort.





Aleix Pol talked about the "All About the Apps" goal. Illustration by Jens Reuterberg (ohyran).

Niccolò Venerandi took over and talked about the "Consistency" goal. The Consistency goal seeks to make sure all KDE elements integrate well with each other, and makes sure the look and feel of apps and environments are similar across the board. He explained, with live drawings, how people working on this goal establish rules for each of the elements in graphical elements, such as app windows, and how that has contributed to apps gracefully integrating with each other.

Méven Car then talked about all the progress made by the people working on the Wayland goal, and Vlad Zahorodnii covered the next steps of what would soon be arriving.

All the goal Champions, Aleix, Meven and Niccolò, got together with Adam Szopa and Lydia Pintscher and talked about their projects and how they help focus the efforts of the KDE community. Although, as Lydia pointed out, it is not the only way to get things done in KDE, it is a good way to start and understand what KDE's main concerns and aims are.

The morning ended with four lightning talks, in which Anupam Basak talked about how to use Qt with Python; Carl Schwan analyzed the health of the KDE Community with some very illuminating (and colorful!) graphics and charts; Andreas Cord-Landwehr talked about SPDX License Markers in KDE, that is markers placed inside code that identifies the license the code is distributed under and that can be read by a machine (saving a lot of money in legal fees!). Finally, David Redondo talked about Power Profiles in Plasma, that is, how Plasma manages the power it needs, the state of the battery and so on.

The evening talks started at 17:00 UTC with the Sponsors' Talks, where the companies and organizations that helped finance Akademy explained their products and services, and the role Open Source software plays in their businesses. Mbition, KDAB, Qt Company, GitLab, Fedora all delivered talks.

Later, in Room 1, Nicolas Fella used his talk "What's cooking for KDE Frameworks 6" to explain the work being carried out to build KF6. KF6 is the version of KDE Frameworks which will use, and be compatible with Qt6. In the talk, developers learned about upcoming changes and how they could contribute to the effort.

Meanwhile, in Room 2, in his talk "Staying Indoors - OSM indoor maps for KDE Itinerary", Volker Krause observed that providing information about the insides of building, such as big stations and airports, can be vital for travelers. Unfortunately, often the data you get from online services is confusing and overwhelming. Volker explained how KDE's Itinerary app splits up the information, making large buildings easier to navigate.

At 20 past six, Dan Leinir Turthra Jensen took over in Room 1 and told us their History of Software Distribution, and explored the many ways they have tried to get software to users.

At the same time, in room 2, Daniel Vrátil, introduced us to C++ Coroutines, a new feature in C++ 20. He explained how coroutines can be used with certain Qt operations, such as DBus calls, network replies, and so on.

Then Massimo Stella presented Kdenlive, KDE's advanced video-editing software. In his talk, he covered the Kdenlive's new features, such as the "smart" subtitler, the zoom bars in the timeline, and same-track transitions.

Meanwhile, in room 2, Kevin Ottens, in his presentation "KF6 the Architecture Overview - Time to Slice Things Up Yet Again", talked about how the KF5 offer was originally structured and how it has led to some issues over time. He then explained an idea that could help improve things while moving to KF6.

Back in room 1, Paul Brown and Aniqa Khokhar explained to attendees how they can take advantage of the Promo team in "Promo as a Service", and how KDE members could improve the visibility of their projects.

Meanwhile, in room 2, David Edmundson was delivering "Wayland for Qt application developers". In his talk, he explored what Wayland means for Qt application developers, and some common traps and pitfalls and how to avoid them.

During the last session in room 1, Cornelius Schumacher explained in "Towards sustainable computing" what the impact computing had on our environment and talked about strategies KDE could adopt to become more efficient, and how developers could create apps that used less energy.

Finally, in room 2, Alexander Saoutkin used his talk "ARM Memory Tagging Extension - Fighting Memory Unsafety with Hardware" to explore the threats posed by memory unsafety in C++ programs and some new tools that help minimize them.

Although it is not the best way to watch the talks, if you are in a hurry to watch a specific session, there is a raw and unedited recording of the talks on YouTube:

Meanwhile, our video editors are hard at work cutting and improving the footage, and we will have high quality videos of the talks up and available soon.

My Akademy 2021

Saturday 19th of June 2021 10:00:00 PM

The Akademy conference weekend (schedule) is almost over already. I was unavoidably detained for saturday and haven’t been able to reserve much time for it this weekend or the rest of the week. On sunday morning I hopped off my bicycle 15 minutes before the start of the KDE e.V. board report, so I’ll let you know that I was wearing bike shorts while looking .. um .. boardly up top. Thanks Tomaz for noticing my long flowing blonde hair. Beside the KDE e.V. AGM and KDE e.V. board office hour I only have one thing going on, my only thing that isn’t administrative in nature: Qt6 on the BSDs; giving it some love and bringing the packaging up-to-date on FreeBSD (catching up with OpenBSD). That’s thursday at 1600 UTC (1800 CEST, so I’m skipping dinner for it). Join us for some ports hacking.

KDE e.V. Windows Store Statistics

Saturday 19th of June 2021 08:19:00 AM

Now that Akademy 2021 has started, let’s take a look at the current statistics of all applications in the Windows Store published with the KDE e.V. account.

Last 30 days statistics

Here are the number of acquisitions for the last 30 days (roughly equal to the number of installations, not mere downloads) for our applications:

A nice stream of new users for our software on the Windows platform.

Overall statistics

The overall acquisitions since the applications are in the store:

Okular and Kate finally went over the 100,000 acquisitions :=)

Help us!

If you want to help to bring more stuff KDE develops on Windows, we have some meta Phabricator task were you can show up and tell for which parts you want to do work on.

A guide how to submit stuff later can be found on our blog.

Thanks to all the people that help out with submissions & updates & fixes!

If you encounter issues on Windows and are a developer that wants to help out, all KDE projects really appreciate patches for Windows related issues.

Just contact the developer team of the corresponding application and help us to make the experience better on any operating system.

Akademy 2021 – I

Saturday 19th of June 2021 07:55:49 AM

I am still digesting the load of information that Marc Mutz gave in his intense training session last night between 6 and almost 11 p.m. about C++/STL history, containers, iterators, allocators, the Non-Owning Interface Idiom and all that other good stuff. Great job Marc.

Today, the talk session starts and I have picked a few talks and presentations that I want to attend. Let’s see how that fits with the other things going on in my life. Here’s my plan for today:

  1. KDE is All About the Apps – as an app developer in the community this seems to be a must
  2. Health Analysis of the KDE Community – Curiosity drives me there
  3. Collabora Office Hour – Alvaro is a former KMyMoney dev -> a must
  4. What’s cooking for the KDE Frameworks 6 – I just follow the Qt6 port on an irregular basis, so it’s time to catch up
  5. C++ Coroutines and Qt – General interest in new C++ language features
  6. KF6 the Architecture Overview – Companion to 4. (which I may miss) and it’s always good to know about the big picture

And maybe I roam around in one or the other additional session. See you soon then (once I win over the technical details).

This week in KDE: Expandable tooltips and more

Saturday 19th of June 2021 05:10:28 AM

This week we have yet another interesting new user interface feature to talk about. The old “What’s This?” feature has been re-worked as a shiny and new user interface convention we’ve come up with: expandable tooltips! Many tooltips in KDE apps that use the KXMLGui and Kirigami frameworks now have a little label saying “Press Shift for more”, and if you do so, it will show you the longer text. This makes the feature much more useful since it’s invokable right at the point where you would need it. Big thanks to Felix Ernst for this work! It will land in Frameworks 5.84.

https://i.imgur.com/aoozE8G.mp4 Other new Features

You can now hold down the alt key to drag underlined files from Konsole into other apps for various purposes! (Tomaz Canabrava, Konsole 21.08)

Bugfixes & Performance Improvements

When an overlay is active in System Monitor, clicking on a different page in the sidebar now closes the overlay before navigating to the clicked-on page (Arjen Hiemstra, Plasma 5.22.1)

Deleting a page in System Monitor now removes it immediately even if you were in that page’s Edit Mode when you deleted it (David Redondo, Plasma 5.22.1)

Fixed a recent regression about Task Manager tooltips not properly updating their header text when the window’s title changes (Henri Chain, Plasma 5.22.1)

Autostarted applications listed in System Monitor no longer display the wrong icons (Nicolas Fella, Plasma 5.22.1)

Fixed various rendering glitches when using the Vulkan graphics system (Xaver Hugl, Plasma 5.22.1)

The “Dialog Parent” effect that dims windows behind dialogs no longer flickers when the dialog is closed (Vlad Zahorodnii, Plasma 5.22.2)

Discover no longer notifies you constantly about updates even when there are none (sorry about this regression) (Aleix Pol Gonzalez, Plasma 5.22.2)

When Plasma is restarted–either manually or automatically because it crashed–various Plasma-related shortcuts such as the Meta+number keys to activate Task manager items no longer stop working (David Edmundson, Plasma 5.22.2)

In the Plasma Wayland session, the cursor is no longer briefly invisible after a screen wakes up (Xaver Hugl, Plasma 5.22.2)

One specific text label on the System Settings Virtual Desktops page (you know which one I’m talking about) no longer gets inappropriately elided when there’s still plenty of space (me: Nate Graham, Plasma 5.22.2)

In System Settings’ Login Screen page, the sheets that appear for syncing settings and changing the wallpaper now disappear after you use them, providing confirmation that the action that you triggered succeeded (me: Nate Graham, Plasma 5.23)

Tooltip shadows throughout Plasma no longer have a broken appearance in their corners (Marco Martin, Frameworks 5.84). Popup/dialog/OSD corners still have problems, but we’re working on that too.

User Interface Improvements

For a cleaner appearance, Gwenview’s sidebar is now hidden by default, and its visibility is now a global setting rather than a per-mode setting; when you show it, it will now stay shown, and then when you hide it, it will now stay hidden (Felix Ernst, Gwenview. 21.08)

Gwenview’s display of tags in the sidebar (when it is visible) is now prettier (Noah Davis, Gwenview 21.08):

Gwenview no longer uses the space and backspace keys for navigation by default, to prevent the space key from conflicting with the play/pause action when you navigate to a video. To navigate between items, just use the arrow keys (me: Nate Graham, Gwenview 21.08)

Konsole’s split view feature will now snap split dividers to the location of other dividers when you drag them (Tomaz Canabrava, Konsole 21.08)

Clicking on any of the buttons for bold, italic, etc. in a Sticky Note widget no longer de-focuses the text area (me: Nate Graham, Plasma 5.22.1)

Discover no longer shows you a notification telling you that an offline update succeeded, because if you’re able to see it, of course it did! (me: Nate Graham, Plasma 5.22

The Breeze SDDM theme now shows a more appropriate UI for accounts with no password set but auto-login turned off (Tadej Pecar, Plasma 5.23):

The clipboard now remembers 20 items by default, up from 7 (Felipe Kinoshita, Plasma 5.23)

Grid items throughout System Settings and the wallpaper choosers no longer lighten the content area when you hover the cursor over them, so that it is always presented accurately (me: Nate Graham, Frameworks 5.84)

…And everything else

Keep in mind that this blog only covers the tip of the iceberg! Tons of KDE apps whose development I don’t have time to follow aren’t represented here, and I also don’t mention backend refactoring, improved test coverage, and other changes that are generally not user-facing. If you’re hungry for more, check out https://planet.kde.org/, where you can find blog posts by other KDE contributors detailing the work they’re doing.

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.

GSoC’21 Week 1 : Building a solid base

Friday 18th of June 2021 06:08:09 PM
Project Overview

GCompris is a high quality educational software suite, including a large number of activities for children aged 2 to 10, some of the activities are game orientated, but nonetheless still educational.

Currently it has more than 150 educational activities for kids. The goal of GCompris in GSoC’21 is to add more activities. I proposed (proposal link) to add the following activities during GSoC coding period:

  • Deplacements : It is a maze activity. The user will be be given a path on the grid. The user has to encode / decode this path, in the form of elementary movements defined by ‘arrow keys’.
  • Oware: This is traditional board game, popular in many parts of Africa. The game starts with 48 seeds equally divided between two players. The objective of the game is to capture more seeds than one’s opponent. The game is over when one player has captured 25 or more seeds, or both players have taken 24 seeds each (draw).
Community Bonding Period

During the community bonding period, I discussed the strategy and structure of the activities that I was going to work on during the coding period. I discussed design and also the structure from programming point of view with my mentors: Timothee, Johnny Emmanuel and Deepak . We discussed the requirement of assets for these activities as well.

Before starting with GSoC, I was working on adding 4 different ordering activities to the GCompris project. During the community bonding period, I continued my work on that project, and finished it (Merge Request). Following activities were a part of this merge request:

1. Ordering Numbers

Kids are given a few random numbers to sort in ascending / descending order.

2. Ordering Alphabets

Kids are given a few random letters in their preferred language, and they are asked to order them in ascending / descending order.

3. Ordering Sentences

Kids are given jumbled words and are asked to form a meaningful sentence by reordering them.

4. Ordering Chronology

Kids are given images of events. They have to sort those images in correct chronological order.

First Week Report

During the first week, I worked on building a solid base for the ‘Deplacements’ activity. I initialized a basic structure of the interface, and also initialized a basic structure of the datasets that will be required for this activity.

I took care of the modularity of the code. I kept the code as flexible as I could make it, so that it can be easily extended later on.

One of the major challenges that I am facing right now is to make the layout responsive, and make it adapt to the screen size for vertical devices. One my mentors Timothee Giet suggested me to use states for this, and display the layout according to the state variable. I’m working on it, and I believe I’ll get it working soon.

What next?

I’ll be starting with adding the actual game mechanics logic now. After this, I have to work on 4 different variants / modes of this activity. The base code for all these activities would be common, just special cases need to be handled separately for the individual activities. After finishing this activity, I have to move on the development of the next activity, Oware.

I am having a great time contributing to the project. Each day has a new learning for me. I learn something new everyday in this journey. With the support of awesome mentors, who make sure all our doubts are resolved as soon as possible, it has been a pleasant journey. I am looking forward to complete these activities, and give back to the community.

Last but not the least, thanks for taking out time to read! Stay tuned for further updates!

Stuck Updates Fix

Friday 18th of June 2021 02:09:36 PM

When rolling out a new feature that lets you skip (offline) updates on boot-up earlier this week we have messed up and also brought in a nasty bug that prevents updates from applying. Unfortunately we can’t automatically rectify this problem because, well, updates are never applied.

In case you find Discover showing the same updates over and over again, even after rebooting to apply the update, you may be affected.

To resolve this problem simply press the ‘c’ key on your keyboard when the boot screen is saying “Preparing system updates… press ‘c’ to cancel”. When you have done this once, ‘c’ will behave correctly for future updates and cancel the update if you want to cancel the update temporarily to get to your desktop quickly.

If pressing ‘c’ for one update does not resolve your problems you are definitely afflicted by a different issue. Particularly when discover informs you of pending updates, but when you open the application there are none listed that’d be a different problem.

See also Bug 438809 – offline updates are not installed on restart

KDE neon now on Linux 5.8

Friday 18th of June 2021 01:52:16 PM

Here at KDE neon we pride ourselves on giving you the latest from KDE built pronto and QAed and shipped to you with no questions asked. We also base on the stable Ubuntu LTS 20.04 release giving a generally stable system. If you want an updated version of an app which isn’t from KDE we advise you to use a non-distro package from the Snap store, AppImage or Flatpak. But Linux has one property which is still inconvenient for the end user even the more nerdy of end users, which is that drivers are shipped with the Linux version you get and there’s no stable programmer interface for them so they can’t easily be shipped externally. That means if you use Linux 5.4 which is what comes with KDE neon and Ubuntu 20.04 you will get drivers which are a few years old, which is no good for those shiny new AMD Radeon graphics chips. So we’ve now switched the installable images to the HWE build which brings in Linux 5.8. Neon installs should just install it on upgrade and use it on the next boot. Chat on our forum and report bugs on bugs.kde.org as ever.

Web Review, Week 2021-24

Friday 18th of June 2021 11:00:20 AM

Getting ready for giving out a training tonight. Still, here is my latest web review for the week 2021-24.

Farewell, Millennial Lifestyle Subsidy - The New York Times

Tags: economics, uber

Looks like people are finally waking up it was a whole economy built on sand…

https://www.nytimes.com/2021/06/08/technology/farewell-millennial-lifestyle-subsidy.html


Apple admits it ranked its Files app ahead of competitor Dropbox - The Verge

Tags: apple

Never forget who owns the walled garden you get your software from…

https://www.theverge.com/2021/6/11/22528701/apple-rank-own-app-over-competitor-files-dropbox-wwdc-2017


If the Scrum Alliance Cared

Tags: tech, scrum

Clearly that’s a big “if”… I don’t think we’ll ever see the Scrum Alliance really care about developers.

https://ronjeffries.com/articles/021-01ff/what-if-sa-cared/


10 Admirable Attributes of a Great Technical Lead | by Elye | Jun, 2021 | Better Programming

Tags: tech, management, leadership, tech-lead

I think this is a very good summary of what being in the position of a tech lead entails. I especially like the bottom line of this article: it’s a constant balancing act between your heart or your mind.

Most of the points pushed forward in this article are things I’ve been trying to achieve for a long time. It also summarizes fairly well most of the topics I go through for coaching situations with tech leads or people growing in the position.

https://betterprogramming.pub/10-admirable-attributes-of-a-great-technical-lead-251d13a8843b


Disasters I’ve seen in a microservices world

Tags: tech, microservices, backend, frontend, databases

Stay away from the hype and introduce complexity in your systems only if it’s warranted by the problem space you have to tackle. Most organizations don’t need microservices, use them responsibly.

https://world.hey.com/joaoqalves/disasters-i-ve-seen-in-a-microservices-world-a9137a51


Book summary: A Philosophy of Software Design

Tags: tech, design, programming, complexity

Second time I bump into this book being mentioned somewhere. This good summary really makes me want to read it. At least it gives a clear overview of complexity and how it’s tied to other softer topics. I especially like the distinction between tactical and strategic, it’s one I do often. I think I’m particularly willing to read the chapters about comments and TDD… from the summary it seems it’s where I’m the most at odd with the ideas in there.

https://freshman.tech/philosophy-of-software-design-summary/


A collection of modern alternatives to common unix commands

Tags: tech, command-line

A collection of nice CLI tools. Got some of them already, still there are a few more which look interesting.

https://github.com/ibraheemdev/modern-unix


Identify anything

Tags: tech, command-line, python, security

Looks like a very interesting tool, in particular for security purposes.

https://github.com/bee-san/pyWhat


##linux on freenode – Linux.Chat

Tags: tech, irc, freenode

Freenode keeps going down the drain. It feels like watching a train wreck.

https://linux.chat/linux-on-freenode/


Freenode commits suicide, is no longer a serious IRC network

Tags: irc, freenode

This is a sad death…

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


Bye for now!

Cutelyst 3 is out!

Thursday 17th of June 2021 11:09:26 AM

Cutelyst, the C++/Qt web framework just got a new major release.

Under the hood it now has both Qt5 and Qt6 support, but because of this a few things had to be changed, the most important one was QMap usage as a multi-key container had to be changed to QMultiMap, if you used ParamsMultiMap types or auto when assigning there’s probably little to do, one major exception is that if you still use Grantlee it might not work well, but Cutelee is there with fixes and is almost ported to Qt6.

Another API changes were on the authentication classes that have some friendly methods for QString passwords, WSGI module is now called Cutelyst::Server, it allows you to embed Cutelyst on other applications or have it as a stand alone executable, allowing for better LTO as you can get all stuff compiled as static libraries.

For the future I’m leaning towards increasing minimum version to Qt 5.12 (sadly means LGPLv2 for Qt5.6 will be gone) to start using QStringView where possible.

https://github.com/cutelyst/cutelyst/releases/tag/v3.0.0

GitHub Notification Actions

Wednesday 16th of June 2021 10:00:00 PM

Calamares, a Linux system installer used by a few dozen different distro’s, is hosted on GitHub. The source code and issues live there, and the website is run from GitHub pages. This post meanders around GitHub actions – things that happen in response to changes in a project – and how I built a Matrix-notification-thing for Calamares.

Calamares is not a KDE project – call it KDE-adjacent, I guess – so there is a bunch of slightly-different technology and topics than a KDE project would use on KDE Invent, which is a GitLab instance.

The project has two main repositories (calamares and calamares-extensions), and project participants are interested in notifications about two main things:

  • issues opened and closed
  • Continuous Integration builds (CI, after a push and nightly across more platforms)

GitHub Actions provides a (terrible, YAML-based) language for writing down things to do and when to do them. The Calamares project uses this to do notifications for the things we’re interested in. At some point, I think GitHub had specific integrations for IRC notification; since then Calamares has moved most of its messaging to Matrix and we had to re-jig the setup.

All I Wanted Was a Shell Script

Sending notifications to Matrix is actually pretty simple: anything that can do a HTTP POST request will do, which means that the Swiss-army-knife called curl is your best friend.

The Matrix API Documentation is pretty good (and curl-centric). I registered a new account called calamares-bot on the Matrix.org homeserver, and then went through the following steps:

  • Get an access token by following the steps in the Login section. This gives me a random string which I’ll call MATRIX_TOKEN.
  • Figuring out the room ID for #calamares:kde.org. I think I started up Element in a web browser to do that, since the “joining a room via an alias” documentation didn’t make sense to me – and all I have is a canonical name, I don’t even know if that counts as an alias. This is another random string, which I’ll call MATRIX_ROOM.
  • The two strings can be used to send messages to a room: curl -XPOST -d '{"msgtype":"m.text", "body":"hello"}' \ "https://matrix.org/_matrix/client/r0/rooms/$MATRIX_ROOM/send/m.room.message?access_token=$MATRIX_TOKEN"

    Here, the documentation is pretty good again (copy-and-paste errors above are my fault).

So what I really want is to run that curl command in response to new issues and build results. It’s just a (one-line!) shell-script, how hard can it be?

Just One Shell Script

GitHub has an “actions marketplace” which encourages you to use arbitrary scripts from other users as actions. Those scripts run in the context of your own CI, along with whatever secrets you hand them. What could possibly go wrong?

The documentation encourages referring to the arbitrary scripts from third parties by the full hash of the corresponding Git commit. I suppose full hashes will mitigate most of the supply-chain attacks on actions, but I fully expect some popular action to be bought up and have a tag changed leading to CI compromises. There’s also script hardening documentation which is both terrifying and laughable (I can see that my own scripts are vulnerable; this is C++ level of footgunnery, provided via Javascript and YAML).

With that in mind, I set out to do-it-myself, in a repository controlled by the Calamares project. That way at best we can compromise our own CI and not somebody else’s.

Initially I had a shell script, in the Calamares repository itself, to do the notifications, but there’s a curiosity: actions run with no checkout of the repository, so to get the script I’d have to clone the repo first. For CI builds that makes sense, but not so much for notification of issues being opened or closed.

So I need my shell script, (remember, this is going to be one line which calls curl with suitable data) to live somewhere that doesn’t need to be checked out.

But They Wouldn’t Give It To Me

Regarding this section title, yes they would, but otherwise I’d miss the opportunity to misquote more bits of Suicidal Tendencies’ “Institutionalized”.

What’s not immediately obvious to my old-school shell-scripting mind is that GitHub’s “compound runners” can effectively be shell scripts, that they can live in a separate repository in subdirectories, and that they’re magically available.

Here is the YAML bla-bla that wraps my one-line shell invocation of curl. There’s input and output parameters being defined and then used in the script – the script being the value of the run key down at the bottom.

So at this point I have

  • a separate git repository,
  • containing a subdirectory,
  • with 25 lines of YAML directing one line of shell-code.

But it’s easy to call! All I need is 5 lines of YAML at the call site (e.g. a GitHub workflow) to invoke the action: one to name it, and 4 lines to pass the parameters in (the strings MATRIX_TOKEN and MATRIX_ROOM and the message to send).

Since the token and room strings can be used to send messages to a given (possibly-private) room as a particular user, they open up the possibility of impersonation; they need to be secret. The repository and organization Settings pages on GitHub have a tab where a secret string can be named and stored. Then the string is available to actions, but won’t be displayed or logged unless you do it deliberately.

.. I’ll probably get hit by a bus anyway

I’m not going to think about how many different VMs or docker instances or whatnot get spun up for the purposes of notification – it happens on GitHub’s Azure backend, all automagically. No wonder people mine crypto as part of their CI pipeline.

In overall terms of code-lengte / lines written, this is remarkably inefficient; the only thing gained is that I have a cargo-cult 5-liner for any workflow step that needs notifications (e.g. issues changed or CI run completed). If I need notifications from other parts of the Calamares project – who knows, there might be a Pull-Request-Notifier at some point if external participation picks up – then I’ll have saved a little time.

For now, though, color me unimpressed with the whole thing. It’s a sunk cost, and part of increasing inertia to help with lock-in on the platform (re-doing this for GitLab would mean changing all the bla-bla surrounding the one line curl invocation). The only upside is that I’m running my untrusted code, and not somebody else’s (and I run my code every day, anyway).

PS. You can use this action yourself; if you trust me (bambi-eyes) invoke the action directly; if you don’t, copy the action into a repository of your own. There’s also other, similar Matrix-notifiers for GitHub actions with more-or-less fancy features.

KDE Goals Update – June 2021

Wednesday 16th of June 2021 06:00:00 PM

Hello!

Akademy starts in a few days, and the Champions and I will be focusing on that. However, there are still some interesting updates we’d like to share with you.

Let’s jump right in!

Wayland

With every recent Plasma update (and especially the just released version 5.22) the list of features that are X11 exclusive gets smaller and smaller.

Conversely, many users may not be aware that the opposite is also happening: every day there are more features available on Wayland that cannot be found on X11!

There are many resources available describing the security advantages of Wayland over X11, but the ageing protocol has some other shortcomings as well. For example, the last update we highlighted was the recently released VRR support in 5.22. Among other things, this enables an important use case for me: it allows each of my connected displays to operate at their highest refresh rate. I have a 144Hz main display, but occasionally I plug in my TV, which works at 60Hz. Because of limitations of X11, for everything to work, my main display needs to be limited to 60Hz when both of them are active. But not any more thanks to Wayland!

While the KDE developers always try to bring new functionalities to all users, the above example shows that sometimes, either due to X11 limitations or for other reasons, feature parity will not be possible.

For different, but similar reasons, some other features that are Wayland exclusive are:

You can be sure that the list of Wayland exclusives will grow and grow as work progresses.

Méven and Vlad will have a Wayland Goal talk at Akademy. Check out the details here: https://conf.kde.org/event/1/contributions/5/

Consistency

When you think about consistency, you may think of how different parts of your Plasma desktop should look and behave in a similar way, like scrollbars should all look the same on all windows. Or like when you open a new tab, it should always open in the same place, regardless of the app.

But the KDE developers also think about the bigger picture, like: How can we achieve a consistent experience between your desktop and your phone? Here’s where Kirigami comes in! It makes sense to have applications like NeoChat and Tok on both Plasma desktop and Plasma Mobile, and, thanks to the Kirigami framework, users will feel at home on both form factors. Now I want to see Kirigami apps on a smartwatch!

NeoChat desktop and mobile powered by Kirigami

Speaking of Kirigami, there is work being done on a component called “swipenavigator” to increase its - you guessed it - consistency, among other fixes. Details of the rewrite are in the merge request.

Do you care about looks? Then you’ll be interested in two MR’s: the first regarding better shadows, and the other is the “Blue Ocean” style for buttons, checkboxes etc. There are some details at Nates blog.

Our Consistency Champion Niccolò has a Goal talk during Akademy, so be sure to watch it!

KDE is All About the Apps

As announced on the community mailing list and the Goals matrix room, there was a meeting last Monday to discuss the way forward with the huge list of topics mentioned in the previous update.

In the meeting, the conclusion was to start with the topics regarding the different platforms we support, as well as the automation of the build/release process of apps.

Taking advantage of the upcoming Akademy, the topics will be discussed during the BoF sessions. Check out the schedule to see when you can attend! Also, don’t miss the “Creating Plasma Mobile apps” BoF!

Of course, like the other Goal Champions, Aleix will have a talk on the first day of Akademy, don’t miss it!

Meta

Right after the three Goal talks at Akademy, there will be a KDE Goals round table, a session where Lydia and I will be joined by the Champions to answer community questions regarding the specific goals, and the goal program as a whole.

Later in the event, on Monday June 21st at 18:00 UTC, I will conduct a BoF regarding selecting the next goals! Be sure to join in, if you were thinking about becoming a Champion yourself, or if you’re just curious about the process.

See you there!

This is how I would look like in the Akademy t-shirt, if Akademy was an in-person event this year. And held outside.

C++ Coroutines Two: Electric Boogaloo: co_await a QNetworkReply*

Wednesday 16th of June 2021 05:39:00 PM

If you haven't read my previous blog post on coroutines in C++, you want to do that before reading this blog post.

In the last blog post, I explained how to construct an awaitable Future type.

If you've been tinkering with coroutines, you may have tried the following thing to allow awaiting on a pointer type:

auto operator await(QNetworkReply* it) { // ... }

As far as the C++ compiler is concerned, this ain't kosher, because you're trying to define an operator for a primitive type (a pointer). Your compiler will probably tell you that this needs to be done on a class or enum type.

But that leaves the question of “how do I make a QNetworkReply* co_awaitable if I can't define co_await on a pointer type?” It is possible.

Your promise_type object has more jobs than what I covered in the last blog post. One of them is to potentially provide an await_transform function.

An await_transform function essentially “preprocesses” any values being co_awaited before the compiler attempts to look for a co_await implementation.

In code, if await_transform is defined on a promise_type, any co_await that looks like this:

auto response = co_await pendingValue;

will actually become:

auto response = co_await await_transform(pendingValue);

This is how we co_await a type you can't provide an operator co_await for: transform it into a type you can.

To integrate a QNetworkReply* into our coroutine types from before, this means we need to make an await_transform function that takes a QNetworkReply* and return a future. This is fairly simple.

auto await_transform(QNetworkReply* it) { auto future = Future(); QObject::connect(it, &QNetworkReply::finished, it, [future, it]() { if (it->error() == QNetworkReply::NoError) { future.succeed(it); } else { future.fail(it); } }); return future; }

Make a future, mark as success if the reply succeeds, mark as failure if it doesn't succeed. Easy peasy.

Plonk this function in your promise_type from before.

This now allows you to do this:

Future fetch(QString url) { auto response = co_await nam.get(url); if (response.error() != QNetworkReply::NoError) { co_return response.readAll(); } co_return false; }

You can implement an await_transform for any input you like, and return anything you like, as long as you can co_await it.

The full code for this blog post can be found in a single-file format at https://invent.kde.org/-/snippets/1716. Compile with C++20 and -fcoroutines-ts -stdlib=libc++ for clang, and -fcoroutines for gcc.

A full library built on the style of coroutines introduced here (with type safe template variants) + other goodies for asynchronous Qt is available at https://invent.kde.org/cblack/croutons.

That's all for this blog post. Stay tuned for more C++-related shenanigans.

Contact Me

If you didn't understand anything here, please feel free to come to me and ask for clarification.

Or, want to talk to me about other coroutine stuff I haven't discussed in these blog posts (or anything else you might want to talk about)?

Contact me here:

Telegram: https://t.me/pontaoski Matrix: #pontaoski:tchncs.de (prefer unencrypted DMs)

Tags: #libre

Building RC LEGO with Arduino and Qt

Wednesday 16th of June 2021 02:00:00 PM

Recently my 4 year-old stepson saw a kid with an RC racing car in a park. He really wanted his own, but with Christmas and his birthday still being a long way away, I decided to solve the “problem” by combining three things I’m really passionate about: LEGO, electronics and programming.

In this short series of blogs I’ll describe how to build one such car using LEGO, Arduino and a bit of C++ (and Qt, of course!).

LEGO

Obviously, we will need some LEGO to build the car. Luckily, I bought LEGO Technic Mercedes Benz Arocs 3245 (40243) last year. It’s a big build with lots of cogs, one electric engine and bunch of pneumatics. I can absolutely recommend it - building the set was a lot of fun and thanks to the Power Functions it has a high play-value as well. There’s also fair amount of really good MOCs, especially the MOC 6060 - Mobile Crane by M_longer is really good. But I’m digressing here. :)

The problem with Arocs is that it only has a single Power Functions engine (99499 Electric Power Functions Large Motor) and we will need at least two: one for driving and one for steering. So I bought a second one. I bought the same one, but a smaller one would probably do just fine for the steering.

I started by prototyping the car and the drive train, especially how to design the gear ratios to not overload the engine when accelerating while keeping the car moving at reasonable speed.

Turns out the 76244 Technic Gear 24 Tooth Clutch is really important as it prevents the gear teeth skipping when the engine stops suddenly, or when the car gets pushed around by hand.

Initially I thought I would base the build of the car on some existing designs but in the end I just started building and I ended up with this skeleton:

The two engines are in the middle - rear one powers the wheels, the front one handles the steering using the 61927b Technic Linear Actuator. I’m not entirely happy with the steering, so I might rework that in the future. I recently got Ford Mustang (10265) which has a really interesting steering mechanism and I think I’ll try to rebuild the steering this way.

Wires

We will control the engines from Arduino. But how to connect the LEGO Power Functions to an Arduino? Well, you just need to buy a bunch of those 58118 Electric Power Functions Extension Wires, cut them and connect them with DuPont cables that can be connected to a breadboard. Make sure to buy the “with one Light Bluish Gray End” version - I accidentally bought cables which had both ends light bluish, but those can’t be connected to the 16511 Battery Box.

We will need 3 of those half-cut PF cables in total: two for the engines and one to connect to the battery box. You probably noticed that there are 4 connectors and 4 wires in each cable. Wires 1 and 4 are always GND and 9V, respectively, regardless of what position is the switch on the battery pack. Wires 2 and 3 are 0V and 9V or vice versa, depending on the position of the battery pack switch. This way we can control the engine rotation direction.

For the two cables that will control the engines we need all 4 wires connected to the DuPont cable. For the one cable that will be connected to the battery pack we only need the outter wires to be connected, since we will only use the battery pack to provide the power - we will control the engines using Arduino and an integrated circuit.

I used the glue gun to connect the PF wires and the DuPont cables, which works fairly well. You could use a solder if you have one, but the glue also works as an isolator to prevent the wires from short-circuiting.

This completes the LEGO part of this guide. Next comes the electronics :)

Arduino

To remotely control the car we need some electronics on board. I used the following components:

  • Arduino UNO - to run the software, obviously
  • HC-06 Bluetooth module - for remote control
  • 400 pin bread board - to connect the wiring
  • L293D integrated circuit - to control the engines
  • 1 kΩ and 2 kΩ resistors - to reduce voltage between Arduino and BT module
  • 9V battery box - to power the Arduino board once on board the car
  • M-M DuPont cables - to wire everything together

The total price of those components is about €30, which is still less than what I paid for the LEGO engine and PF wires.

Let’s start with the Bluetooth module. There are some really nice guides online how to use them, I’ll try to describe it quickly here. The module has 4 pins: RX, TX, GND and VCC. GND can be connected directly to Arduino’s GND pin. VCC is power supply for the bluetooth module. You can connect it to the 5V pin on Arduino. Now for TX and RX pins. You could connect them to the RX and TX pins on the Arduino board, but that makes it hard to debug the program later, since all output from the program will go to the bluetooth module rather than our computer. Instead connect it to pins 2 and 3. Warning: you need to use a voltage divider for the RX pin, because Arduino operates on 5V, but the HC-06 module operates on 3.3V. You can do it by putting a 1kΩ resistor between Arduino pin 3 and HC-06 RX and 2kΩ resistor between Arduino GND and HC-06 RX pins.

Next comes up the L293D integrated circuit. This circuit will allow us to control the engines. While in theory we could hook up the engines directly to the Arduino board (there’s enough free pins), in practice it’s a bad idea. The engines need 9V to operate, which is a lot of power drain for the Arduino circuitry. Additionally, it would mean that the Arduino board and the engines would both be drawing power from the single 9V battery used to power the Arduino.

Instead, we use the L293D IC, where you connect external power source (the LEGO Battery pack in our case) to it as well as the engines and use only a low voltage signal from the Arduino to control the current from the external power source to the engines (very much like a transistor). The advantage of the L293D is that it can control up to 2 separate engines and it can also reverse the polarity, allowing to control direction of each engine.

Here’s schematics of the L293D:

To sum it up, pin 1 (Enable 1,2) turns on the left half of the IC, pin 9 (Enable 3,4) turns on the right half of the IC. Hook it up to Arduino's 5V pin. Do the same with pin 16 (VCC1), which powers the overall integrated circuit. The external power source (the 9V from the LEGO Battery pack) is connected to pin 8 (VCC2). Pin 2 (Input 1) and pin 7 (Input 2) are connected to Arduino and are used to control the engines. Pin 3 (Output 1) and pin 6 (Output 2) are output pins that are connected to one of the LEGO engines. On the other side of the circuit, pin 10 (Input 3) and pin 15 (Input 4) are used to control the other LEGO engine, which is connected to pin 11 (Output 3) and pin 14 (Output 4). The remaining four pins in the middle (4, 5, 12 and 13 double as ground and heat sink, so connect them to GND (ideally both Arduino and the LEGO battery GND).

Since we have 9V LEGO Battery pack connected to VCC2, sending 5V from Arduino to Input 1 and 0V to Input 2 will cause 9V on Output 1 and 0V on Output 2 (the engine will spin clockwise). Sending 5V from Arduino to Input 2 and 0V to Input 1 will cause 9V to be on Output 2 and 0V on Output 1, making the engine rotate counterclockwise. Same goes for the other side of the IC. Simple!

Conclusion

I also built a LEGO casing for the Arduino board and the breadboard to attach them to the car. With some effort I could probably rebuild the chassis to allow the casing to “sink” lower into the construction.

The batterry packs (the LEGO Battery box and the 9V battery case for Arduino) are nicely hidden in the middle of the car on the sides next to the engines.

Now we are done with the hardware side - we have a LEGO car with two engines and all the electronics wired together and hooked up to the engines and battery. In the next part we will start writing software for the Arduino board so that we can control the LEGO engines programmatically. Stay tuned!

No, Windows is not copying KDE Plasma

Tuesday 15th of June 2021 09:44:54 PM
Every so often there appear some new pics from developer builds of Windows or even leaks such as the recent Windows 11 preview screenshots. More or less every time this happens there are comments from the Linux side that Windows is copying KDE Plasma – a desktop environment that is, granted, among the most similar...... Continue Reading →

GSoC’21 Week 1: The Beginning

Tuesday 15th of June 2021 09:35:48 PM
Project Overview

GCompris is a high quality educational software suite, including a large number of activities for children aged 2 to 10, some of the activities are game orientated, but nonetheless still educational.

Currently GCompris offers more than 100 activities, and more are being developed. GCompris is free software, it means that you can adapt it to your own needs, improve it, and most importantly share it with children everywhere.

The GCompris project is hosted and developed by the KDE community.

My project goals include adding four new activities to GCompris:

  • Subtraction decimal number activity.
  • Addition decimal number activity.
  • Programming maze loops activity.
  • Mouse control action activity.
Community Bonding Period

During this period I have interacted with my mentors, and discussed multiple design aspects for extending the original decimal activity, so that it can support both addition decimal activity and subtraction decimal activity, I started to add the decimal point character in numPad to support typing it for decimal activities, I managed to add a task for each activity on phabricator to track the progress.

Decimal Activity First Week Report

So, the first week of coding period has ended. It was exciting and full of challenges. I am happy that I am on the right track and making progress as I’ve promised. I have started by adding subtraction decimal number activity, its goal is to learn subtraction for decimal numbers.

Here is a quick summary of the work done last week:

  1. Adding multiple datasets, from which we generate two different decimal numbers.
  2. Creating a new component MultipleBars.qml, from which the largest decimal number is represented as multiple bars, each bar consists of ten square units, some of them is semi-transparent according to the largest number shown.
  3. Adding numPad.qml to the activity, so that we can ask the child to type the result if he represented the result correctly.
  4. Adding TutorialBase.qml including instructions on how to play with the activity.
what’s next ?

I will start implementing Addition decimal activity, and wait for mentors’ reviews on subtraction decimal activity as it is still in progress.

I am delighted to have such an enthusiastic, helpful and inspiring community

That’s all for now. See you next time!

Thanks for reading!