MyGNUHealth 1.0 us out! The GNU Health Libre Personal Health Record is now ready for prime time!

This is great news. Great news because citizens around the world have now access to a Free/Libre application, focused on privacy, that puts them in control of their health.

Health is personal, so is the health data. It’s been years since I got the idea of expanding the GNU Health ecosystem, not only to the health professionals and institutions, but making it personal, accessible to individuals. Now is a reality!

Throughout these years, the mobile health (mHealth) has been governed by private companies that benefit from your health data. Private companies, private insurances, proprietary operating systems, proprietary health applications. Big business, no privacy.

GNU and Libre Software

The GNU Health ecosystem exists because of Free software. Thanks to communities such as GNU, we can have fully operational operating systems, desktop environments, databases and programming languages that allow us to use and write free software. GNU Health is one example.

The Libre Software movement fights for the advancement of our societies, by providing universality in computing. In the case of GNU Health, that freedom and equity in computing is applied into the healthcare and social medicine domains. Health is a non-negotiable human right, so it must be health informatics.

What is MyGNUHealth?

MyGNUHealth (MyGH)is a Health Personal Record application focused in privacy, that can be used in desktops and mobile devices.

MyGH embraces the main health domains (bio-psycho-social). All the components in the GNU Health ecosystem combine social medicine and primary care with the latest on bioinformatics and precision medicine. The complex interactions between these health domains play a key role in the state of health and disease of an individual, family and society.

MyGH has the functionality of a health and activity tracker, and that of a health diary / record. It records and tracks the main anthropometric and physiological measures, such as weight, blood pressure, blood sugar level or oxygen saturation. It keeps track of your lifestyle, nutrition, physical activity, and sleep, with numerous charts to visualize the trends.

MyGNUHealth is also a diary, that records all relevant information from the medical and social domain and their context. In the medical domain, you can record your encounters, immunizations, hospitalizations, lab tests,genetic and family history, among others. In the genetic context, MyGH provides a dataset of over 30000 natural variants / SNP from UniProt that are relevant in human. Entering the RefSNP will automatically provide the information about that particular variant and it clinical significance.

The Social domain, contains the key social determinants of health (Social Gradient, Early life development, Stress, Social exclusion, Working conditions, Education, Physical environment, Unemployment, Social Support, Addiction, Food, Transportation, Health services, Family functionality, Family violence, Bullying, War) , most of them from the World Health Organization social determinants of health.

A very important feature of MyGH is that it is GNU Health Federation. That is, if you want to share any of this data with your health professional in real-time, and they will be able to study it.

The PinePhone and the revolution in mobile computing

Of course, in a world of mobile phones and mobile computing, we need free/libre mobile applications. The problem I was facing until recently, that prevented me from writing MyGNUHealth, was the fact that there was no libre mobile environment. The mobile computing market has been dominated by Google and Apple, which both deliver proprietary operating systems, Android and iOS respectively.

The irruption of the Pine64 community was the eye-opener and a game changer. A thriving community of talented people, determined to provide freedom in mobile computing. The Pine64 provides, among others, a smartphone (PinePhone), and a smartwatch (PineTime), and I have adopted both.

I wrote an article some weeks ago (“Liberating our mobile computing”), where I mentioned why I have changed the Android phone to the PinePhone, and my watch to the PineTime.

Does the PinePhone have the best camera? Can we compare the PinePhone with Apple or Google products? It’s hard to compare a multi-billion dollar corporation with a fresh, community-oriented project. The business model, the technology components and the ethics behind are very different.

So, why making the move? I made the change because we, as a society, need to embrace a technology that is universal and that respects our freedom and privacy. A technology that focuses on the individual and not in the corporation. That moves takes determination and commitment. There is a small price to pay, but freedom and privacy are priceless.

As a physician, I need to provide my patients the resources that use state-of-the-art technology, and, at the same time, guarantee the privacy of their sensitive medical information. Libre software and open standards are key in healthcare. When my patients choose free/libre software, they have full control. They also have the possibility to share it with me or with other health professionals, in real-time and with the highest levels of privacy.

We can only manage sensitive health data with technology that respects our privacy. In other words, we can not put our personal information in the hands of corporate interests. Choosing Libre Software and Hardware means much more than just technology. Libre Software means embracing solidarity and cooperation. It means sharing knowledge, code and time with others. It means embracing open science for the advancement of our societies, specially for those that need it most.

MyGNUHealth will be included by default in many operating systems and distributions, so you don’t have to worry about the technical details. Just use your health companion! If your operating system does not have MyGH in their repositories, please ask them to include it.

Governments, institutions, and health professional need affordable technology that respects their citizens freedom. We need you to be part of this eHealth revolution.

Happy and healthy hacking!

About GNUHealth:

MyGNUHealth is part of the GNU Health, the Libre digital health ecosystem. GNU Health is from GNU Solidario, a humanitarian, non-for-profit organization focused on the advancement of Social Medicine. GNU Solidario develops health applications and uses exclusively Free/Libre software. GNU Health is an official GNU project.

Homepage : https://www.gnuhealth.org

Documentation portal : https://www.gnuhealth.org/docs

The KDE conference Akademy is in full swing and the KMyMoney development team today announces the immediate availability of version 5.1.2 of its open source Personal Finance Manager.

This is a maintenance release as part of the ongoing effort to support our users and fix bugs and annoyances. If you think you can support the project with some code changes or your artistic or writing talent, please take a look at the some low hanging fruits at the KMyMoney junior job list. Any contribution is welcome.

Despite the ongoing permanent testing we understand that some bugs may have slipped past our best efforts. If you find one of them, please forgive us, and be sure to report it, either to the mailing list or on bugs.kde.org.

The details

major

• 414675 Budget not using Fiscal Year
• 436647 Overwriting a gpg-encrypted file results in a zero byte file

crash

• 430176 Crash when extending selection of filtered transactions beyond top of list
• 434605 crash when importing csv with missing category
• 438069 Crash when selecting views in newer Qt versions

normal

• 350904 Net worth currency not updated when changing the base currency
• 388793 No price label on editing securities
• 396016 KMYMoney GPG option is grayed out even though GPG installed
• 396313 rounding errors in currency conversion of investment transactions
• 399230 KMyMoney uses incorrect path to detect presence of GPG secret keyring on Windows
• 403196 Displaying the ledger for a category shows the wrong account
• 422561 A half-empty PRICEPAIR causes app to crash when attempting to update prices
• 425333 no pre-defined account templates on a mac
• 430813 Danish account templates won’t load
• 431248 Payee Default Category not saved unless manually selected
• 431294 Price editor: Enter on manual price has no effect
• 431482 1 Online Quotes does not work and can not be corrected
• 433694 reconciliation removes the history
• 433855 Settings for “Hide reconciled transactions” are not synced
• 434226 Default regex to extract currency rates does not support results in exponential form
• 434573 built-in calculator widget can extend beyond main window
• 435488 CSV importer does not support ISO date format
• 435512 When matching an assigned and unassigned transaction, KMM may leave the resulting category empty
• 435752 Selecting icon sets is not supported on Windows
• 435837 messages from the aqbanking plugin are swallowed
• 435856 ofx import ignores banking transactions in invenstment account since libofx upgrade to 0.10
• 436766 Selection of security accounts does not work for some investment reports
• 437332 We should default to yahoo for any new securities
• 437452 QR-TAN support is not working properly
• 437810 CSV importer should trim the column contents before importing
• 438328 Payee name in schedule is not updated in all accounts
• 438529 App won’t fully quit on macOS
• 438973 Cannot right click and Go To a counterparty split if it is a category
• 439006 New account wizard always defaults to account type “Checkings”

minor

• 437398 typo in Reconciliation Wizard text

wishlist

• 186616 Entering negative amounts in Split window
• 397918 Sort the favorite reports on the home screen in alphabetical order
• 405383 Add python3 support for weboob plugin
• 433662 No visual representation of the reconciliation history

translations

The Slovenian translation team provided an initial Slovenian translation which made it into this release.

A complete description of all changes can be found in the changelog.No block selected.

This is good news for all of you that have been asking for AudioTube binaries. A nightly flatpak build is now built regularly on KDE’s binary factory. The community wiki explains how to install from the nightly repository.

In the meantime I have been working on getting AudioTube through KDEReview, which is going nicely so far. It should soon get stable releases as part of Plasma Mobile Gear.

On Sunday, I made it to all but the last one of the presentations and talks I wanted to go. The session about porting applications to Qt6 was very interesting and I made a few notes that I may later turn into issues on KDE’s Gitlab infrastructure for the KMyMoney project. The talk on How we can solve the personal data problem was not so much related to KMyMoney and its use of the data but nevertheless interesting. Let’s see how this initiative evolves over time and which impact it can create. I added another talk on the fly that was again on Wayland and again presented by Dave Edmundson. Very interesting concepts which I am looking forward to see in distros hopefully soon.

On Monday, I had to go to work (which currently means going upstairs into my home office). In the afternoon I joined the General Assembly of the KDE e.V. where I had the role of the official note taker. They still have to be converted into a readable form for everyone and also for the German authorities. Due to work, I won’t have much time to visit BoFs throughout the week. Maybe one or two as time permits but I still don’t know.

Now working a bit on the KMyMoney release which is scheduled for …… oh, tomorrow.

It’s the second day of Akademy (for the second year, in an online form, for obvious reasons) and still a full week of goodness to come with a lot of interesting bofs and social events.

I gave a talk about the future of Plasma and what to expect from Plasma 6 as an architectural standpoint. How we can make things simpler, faster, more stable and more intuitive to develp against. (Sorry, no pretty pictures here )

Here is a synopsis of my talk (slides here), I hope it’s clear enough to the occasional reader:

The topic of this talk will be unfortunately very far removed from pretty pictures, I’m going to talk about the non visible aspects of Plasma: The structure of Plasma Framework, how the desktop is loaded, what basic api a developer can use to write a plasmoid.
For those who attended yersterday training by Kevin, the first part will have some repetitions, but let’s refresh it a moment, then i will talk about some deas on how to streamline it and what changes we would like to have for KF6/Plasma6

First of all, a bit of history: Plasma was introduced with KDE 4.0, in those “interesting” times

Back then, the structure was as follows:
It was based on a Qt technology called QGraphicsView, which nowdays is kinda deprecated. Plasma doesn’t use it anymore, some apps still do, like the Dolphin icon view, still used a lot in Gwenview, and something will need to be done about it.

The center was a QGraphicsScene, called the Corona, which seems incredible nowdays but it was a complete innocent name back then! (referring to the Sun Corona, where the Plasma lives)

The Corona loads inside its scene QGraphicsWidgets objects called Containments, and manages views for each containment: every containment that is associanted to a phisical screen, will have a correspondece 1:1 with a view and views can be eother of Desktop type or Panel type

Each Containment can contain many Applets, which will be either desktop widgets or panel components like the start menu, task manager and so on, and containment itself is a particular type of Applet, so it’s a subclass of it.

Applets own a Package of files, together they form a Plasmoid. Plasma::Package was then splitted out of Plasma-framework and became the KPackage framework

In this way is possible for the user to build its own perfect desktop ui out of a vast choice of pieces.

In KDE4 times, Plasma supported a wide variety of bindigs, even if most of the applets were implemented in C++
We had pure javascript (before QML wasa thing), Python, Ruby and later we added QML support.

In Plasma5 things changed quite a lot, as it was obvious that QML was going to be the future, and qgraphicsview was having huge performance problems (when resizing large applets it could go down even to 4-5 fps)

So we went all with the QML scenegraph, having much faster and hardware accelerated things in the process.
Corona, Containment and Applet are no more graphical objects but judt QObjects that manage only logic, not the visualization having a better separation
On the downside that meant that the qml binding became the only way to write plasmoids, losing the possibility for using Python and Ruby, but all the binding infrastructure remained there, which became a significant overhead without a real reason.

So now with KF6 coming: What parts of the Plasma architecture are still needed and mostly ok? what are kinda redundant and not necessary anymore? should we split something? how we can improve things in general?

A thing we should split is the Plasma Svg support, just like KPackage can be really useful elsewhere for apps as well. Even if is just for basic svgs, due to QtSvg it’s based on, It adds some nice features on top: caching of the rendered images which helps a lot with load times, it can optionally color svgs with stylesheets and offers support for those nine patch rounded rectanles rendering with sone support for hardwaare acceleration when used on QtQuick. IT has both QtQuick and classic QPainter based API

One that should probably instead be dropped are Dataengines: they were designed with the limited JavaScript api in mind and had quite a hefty goal: to give a common async job based api to access all kind of information, even remotely, to stream informations also on widgets of another computer (KDE4 had thins kinda working)
However in the end the implementations ended up being not so good with pretty ugly code.
With QML it became way easier to just bind QObjects with properties, signals and slots for the logic instead.
They can go in a Plasma5Support porting aid in Workspace

The parts that loads the layout from disk to a Loading the layout from disk to a qobject representation are pretty good right now, and save for some API fixes it can be very similar in Plasma6 as well.
The layout is saved in the appletsrc file, which at startup is read by the Corona and reads the first level of the config file, which represents the containments, that will be instantiated from the plugins.
Corona will check what containments are assigned to a screen which is connected, and those will get a QQuickView, both panels and desktops.
At this point containments will load all the applets in them and instantiate also the corresponding QML and use their oown internal logic to layout the applets, as linear layouts in panels, flee floating in desktops.

Another important part are shell packages
They were born in Plasma Active to do a mobile optimized shell, then the shell of Plasma Active basically became the Plasma5 unified shell for every device and the shell packages are here too, to allow some personalization to adapt the shell to a different kind of device, ad desktops, phones, mediacenters and so on have different ui requirements
In Plasma6 i would like them to be a bit more powerful.

ScriptEngines are a way to wrap the Api of Applet Containment and so on, in a more “limited” way, so that the kde4 times javascript bindings could use them without being “dangerous” Unfortunately those are still used in the QML plasmoids nowdays, but the whole infrastructure should be removed. I would still like some way to bring back Python in plasmoids, but with a different mechanism compared to old scriptengines

I made a prototype as a Plasma-framework fork in my personal area on invent: https://invent.kde.org/mart/Plasma-framework is still not completely functional, but i do have a very simpleshell loading a qml containment and a plasmoid inside it which removes all of the AppletScript intermediary, and the “plasmoid” object is directly the Applet* instance, not a wrapper anymore.

The first phase of loading works in the same way, corona reads appletsrc, instantiates the Containments and in turn the containments instantiate the Applets.
The shell creates the actualwindows, a view for each containment which is associated to a screen, the view when gets assigned to a containment ensures the QML ui for the containment is loaded.
The QML part of the containment, when it gets a new Applet*, it creates an object of type AppletContainer which will take care of making sure that the qml part of the applet is loaded, and this will go in whatever layout manager the Containment implements.

The QML part of an Applet is as is now, shipped in a KPackage.
Now, the root element instead of being an arbitrary item, is forces to be a particular one: AppletRepresentation (error if that’s not the case) its api is purely providing components property for the compact and full representation.

This is a very basic example:

import QtQuick 2.15 //3
     import QtQuick.Layouts 1.0
     import org.kde.plasma.core 6.0 as PlasmaCore
     import org.kde.kirigami 2.15 as Kirigami
     18 – 25 June 2021
     PlasmaCore.AppletRepresentation { // This non graphical element is the mandatory root, won't load with a different one
         // As is today, 99% on the times shouldn't need a compactrepresentation
         compactRepresentation: Kirigami.Icon { // Hopefully this can replace PlasmaCore.IconItem
             source: "start-here"
             TapHandler {
                 onTapped: PlasmaCore.Plasmoid.expanded = !PlasmaCore.Plasmoid.expanded
             }
         }
         fullRepresentation: Item {
             Layout.minimumWidth: Kirigami.Units.gridUnit * 10 //plasmacore units should be migrated to Kirigami
             Layout.minimumHeight: Kirigami.Units.gridUnit * 22
             Text {
                 text: PlasmaCore.Plasmoid.title // all accesses to PlasmaCore.Plasmoid are pointers to the same Applet* instance
             }
         }
     }

Most on the times, compactRepresentation is not needed, the default shell-provided icon will be used but can be overridden if needed (or explicitly be set to null if we want applets to not be collapsible, like the task manager)

The shell packages may become more powerful if we instead of providing root items for the views, which are desktops, panels and config dialogs, they can provide the view window themselves, so that those views can be custom provided plugins as well, perhaps also useful for very custom panel containments, like Latte Dock, to be able to be loaded in the same Plasmashell process.

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 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 ‘?’. It’s proly not terribly useful for top-rated lists, but at the least the reader knows what they’re in for when selecting the story? But that’s all pipe-dreams for now.

Comments

One of the other issues I see with the store and stores in general is that putting content on there means there’s yet another place where an author needs to manage comments. And that can be quite a deal breaker.

I spend some time on getting OPDS 1 implemented into KNewStuff, because it’s a really simple way of representing available content, and I am thinking that for comments I am going to let people link in an rss/atom feed with comments. All the major content management systems have the ability to generate feeds for the comments of a single article, so authors can just link the comment feed for a blogpost, and then on our end we should direct the user to go to the blog if they want to comment.

I think it would be pretty valuable if people could disable comments and instead point at the feed where they keep their comments. There’s some side effects there we need to keep track of, like making sure it’s clear these comments are on that blog and not on the store, as well as some vetting of the comment feed in general, but at the least it’d be in a place where the author can actually control.

This kinda ends up making commenting on the store somewhat pointless at first glance. We could try to see if some of the distributed/federated stuff is useful for assisting people to comment on the author’s comment-feed, but that’s also something that needs investigation.

Conclusion

I’ve been thinking about this all a lot over the past few years. On Saturday there was an Akademy talk by leinir about distributed app stores, and there’s going to be a birds-of-a-feather about that on Friday morning. I might not be available then, so I just wanted to get my thoughts about reviews and comments out there.

In general, I think my adjustments tend to come from a place where I have experience sitting in the author chair, as well as consuming a whole lot of indie stuff, and when looking at those, the approach of the big stores seems really weird.

I don’t think we should copy that kind of behaviour.

I think i went down a rabbit hole

I decided the next printer to make is QDir,

I had to understand how things works, making printers feels like construction, its like you are given a set of tools, to produce an output.

The normal steps i take make a printer is to either dereference d_ptr value or the d value ( they are usuallly included in QT types) , to use ptype nameOfTheValue but in both cases the output was an incomplete type.

After a little search, thanks to this answer from stackoverflow i was able to get the debugging symbols needed to view the internals of the QDir class.

next problem was getting the list of files in the directory show consistently, the files list only show up in gdb when either the method QDir->entryList() or QDir->count() has been called previously, i then decided to call the entryList method when the printer is initialized that way the file list is always shown when QDir is called in GDB.

But the entire application would crash if the QDir has not yet been initialized in memory, because the method i am trying to call does not exist. since none of Qt classes have any fields named something like initialiized, could not find anything for sometime. I was able to figure out that most advanced Qt classes usually have a field named QSharedData.

In QShareddata there is usually a field named ref that only has the value of one when the variable has been initialized, i was able to use that to make a condition statement to print the filelist of the directory if it is iniitalized.

• A Pretty printer for QFileInfo was added.

• A Pretty Printer for QstringRef was added.

the repo can be found here

Next week would be Pointers Printer Goodbye

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 …

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).

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!