Uncategorized – Sjoerd Stendahl

Impressions of my first GUADEC conference in A Coruña

Almost two months ago I went to my first GUADEC conference. While I’ve been busy since then, writing proper travel report has been something I’ve been putting off for a while. Without much further ado, here’s a report of my impressions 🙂

First impressions

It’s always a bit nervous to go visit a conference for the first time. While I’ve been at many conferences where I’ve given talks on international stages before, GUADEC has felt different to me. Mostly because there’s so many people I’ve known from online interactions, yet nobody that I have ever met in real-life.

While it’s usually a pretty obvious conclusion that people that are nice online are so in real life as well, there’s always that voice inside that fears feeling as a complete outsider. While I’m not new to FOSS, having used Linux since 2006, and publishing applications within the GNOME-ecosystem since 2022. I am still a relative newcomer when it comes to engaging a bit more active and vocally.

Fortunately, I found directly that people were really nice. And actively tried to engage me in discussions as well. Many gnomies recognized me, and approached me first. Which nice feeling welcomed into an established community, and definitely makes it easier to engage on other fronts as well.

Talks

There’s been a lot of interesting talks and workshops that stuck with me. I’ll just do the egomaniacal thing and talk about my own talk first: A Brief History of Graphs. The reason I’m putting it on top is not that it’s the best one, but it was obviously a highlight to be able to present my journey within this project to the rest of the GNOME community. The talk is about how I started developing applications, and the lessons learned along the way through community feedback and GNOME Circle. A large part of the main focus ended up being pretty design-focused. But that’s also where much of the lessons are to be learned. You cannot create a great app without putting design first, before the technology. And by that I mean design in a big way. Not how it looks, but think about what it should do before even considering what it could potentially do given the technology at hand. Designing from a technology-first mindset leads to a worse experience for all. It’s food for another blog, but I don’t think it’s a coincidence that every project that explicitly claims to put technology over people¹ kinda sucks.

Me in front of a whiteboard holding a microphone during my talk — My talk during the second day

Either way, it’s been my entry point into GNOME, and has given me a lot of fulfillment over the years. I encourage everyone to start to contribute and engage. It’s gotten much more difficult over the years thanks to shortcuts in the form of text-prediction machines, but there’s really a lot of value of getting it wrong and learning along the way. It wouldn’t be there without the human interactions behind that journey.

Enough babbling about my own talk, here’s just a list of talks that I found particularly interesting:

- - Towards a Local-First Desktop – by Julian Sparber and Tobias Bernard. This in particular is a very important topic to me. I don’t want to sound like an alarmist, but we need to prepare for a future where we may not always have access to a large centralized internet. Not only has this been proven by recent geopolitical circumstances, it’s not like we’re making any progress in avoiding a major climate catastrophe. Local-first technology allows us to remain resilient, even when our centralized infrastructure is under pressure, be it due to geopolitical pressure or by force of nature. Very interesting talk about a very cool technology.
  - The related local-first workshop in particular has been really cool as well. We hacked together a quick implementation of local file transfer within a few hours. Julian showed us how easy it is to get local sync to work with p2panda. I will definitely hack further on this in the future when I have more time on my hands. In the end we managed to send information between devices in a simple Python program.
  - Session Save/Restore – By Adrian Vovk. I never really realized the potential of this feature, Adrian makes a really good case of showing what this feature would provide. But most interesting to me was how complex things are. Once the first prove of concepts were shared a while ago, you’d might make the mistake of thinking it’s just some formal implementation, but there’s a lot of moving parts, and the talk really provides a get a good sense of why these implementations take as long to develop. Fantastic work by Adrian.
  - Performance profiling Mutter, GNOME Shell & apps with Tracy – by Ivan Molodetskikh (YaLTeR). I don’t do Mutter or Shell development, nor have I really used profilers in the past. But Ivan really shows how powerful profilers (Tracy in particular here) can be. I’m highlighting this talk in particular because it inspired me to do some profiling in Graphs (with plain cprofile), nothing as fancy, but we’ve had some significant performance upgrades since then!
  - GNOME Internationalization: accessibility for all over the world – Very nice talk by Guillaume Bernard about internationalization. This one has mostly stuck to me because he has some very clear examples how difficult translations can be. While some things might be obvious, such as the order of words being different, but there’s a lot more subtleties than expected such as counting and pluralization being different as well. He makes a really good case about why it’s important as app developers to use proper practice such as not breaking up sentences, using gender-neutral language, and using the correct categorization and calls to gettext.
  - Beyond #RRGGBB: cross-application color palettes the slightly hard way – By Nathan Willis. While color pallets are maybe not the sexiest topic for everybody, I find it super-interesting to listen how such settings are a bit of an unstandardized clusterfuck where pallets are all stored differently with different names, formats and locations. While I don’t have the impression that this is better in the closed source world, it is less than ideal in creative work when working with multiple applications. Very entertaining talk to listen to.
  - Lightning Talk: GNOME Shell Design Dreams – Obviously the Design dreams talk had to be included. It’s just very cool to see the thoughts and plans on the future of Shell. It’s no wonder this talk did numbers online as well. I’m in particular looking forward to improved search, and improved quick settings.

Traveling to and in A Coruña

Getting to A Coruña was not ideal, but not terrible either. Unfortunately travelling by train was not very viable for us from Sweden, but we are lucky enough to have an international airport in Linköping with direct flights to Amsterdam. From there, it’s single flight to Madrid, and then another one to A Coruña. All by all, we woke up at 04:00, and arrived somewhere around dinnertime.

Traveling to and from the venue worked relatively well. There’s a local app for public transport, where you can bus-rides for dirt-cheap. Buses went often. Walking around within the city was less practical. I realize I’m probably a bit spoiled from my own hometown. But to me A Coruña felt very car-centric with very trafficked roads going everywhere, and only a minority percentage of the public spaces being dedicated to pedestrians. This is not a city where I would dare to take a bicycle, which I was considering at first as an alternative to the bus. Where I’d have to add that I’m saying this having grown up in the Netherlands, where bicycles often are prioritized over both pedestrians and cars. In fact, it’s the only country in the world with more bicycles than people.

The beach was very nice. Being situated at the Atlantic, A Coruña has a wonderfully mild climate compared to most of the European South. Living in the North, temperature is always a bit of a concern when traveling to Southern Europe during the summer, especially nowadays. Temperatures in general were around a comfortable 25°C. We had some warmer days were the temperature passed 30°C, but given we were in a European heatwave where Madrid was close to 40°C, I cannot complain.

The Venue

The venue was hosted at the Informatics Faculty of the University in Coruña. It was easy to find the entrance from the bus, and it offered a nice public space for the coffee breaks and general mingling. The main stage was large and comfortable. The second stage, where I had my own talk was hosted in a regular classroom on the top floor. Whilst it’d have been nice to have the stages somewhat closer, the path to the second stage was labeled very clearly, and we were never over capacity in any of the stages. Another really nice thing is that there were many possibilities to charge electronic devices. On my own laptop, which doesn’t last for much more than a few hours, this has been very useful. Especially during the local-first workshop. The conference itself went smooth with no major delays or unexpected outages. Shoutout to the organizers for making this a success!

One area that I would have liked to see some improvement was the availability of plant-based options. In particular during the first day, there were no non-meat options on the menu, and the restaurant staff did not seem prepared for multiple people wanting to have a vegetarian alternative. This also is related to the fact that vegan options in general seem very niche in Spain (or at least this city), but for an international conference the restaurant staff should probably have been a bit more prepared for such dietary requirements. My initial ambition was to keep myself to completely plant-based options during the trip, but quickly gave up on that when arriving to A Coruña.

Me holding a foot-shaped icecream — I found the official* GNOME-branded ice-cream. (*Not official)

Special Thanks

I really want to give a special thanks to the GNOME Foundation. Partly to all the people who made this possible by organizing this. The local team in A Coruna, the volunteers, and anyone else that took part in organizing this. Also thanks to the people making nicer pictures than me, this includes the staff that has been hired for this. All images apart from the top one with the tower, and me holding an ice cream have been stolen from the GNOME Cloud. The conference overall has been a real nice experience, and it really gives energy to do more. There’s been some areas where I’m getting a bit more further involved in the meantime as well.

Also, I should really thank the GNOME Foundation for sponsoring my travel. It’s been a very expensive trip from Sweden, even when going alone, and I couldn’t have taken those expenses without getting reimbursed for part of the trip. It is really appreciated, and these programs really help for new people to get involved!

1 – To be fair, these projects claim to put technology over politics, not over people. It should be noted that they never mean marginal tax rates, it’s always about policies like the CoC and the right to kick down at disenfranchised minorities such as trans people. Ergo, putting technology over politics in this context is by definition putting technology over people. Unless you don’t count minorities as people. With some of these folks, you never know.

Announcing the upcoming Graphs 2.0

It’s been a while since we last shared a major update of Graphs. We’ve had a few minor releases, but the last time we had a substantial feature update was over two years ago.

This does not mean that development has stalled, to the contrary. But we’ve been working hard on some major changes that took some time to get completely right. Now after a long development cycle, we’re finally getting close enough to a release to be able to announce an official beta period. In this blog, I’ll try to summarize most of the changes in this release.

New data types

In previous version of Graphs, all data types are treated equally. This means that an equation is actually just regular data that is generated when loading. Which is fine, but it also means that the span of the equation is limited, the equation cannot be changed afterward, and operations on the equation will not be reflected in the equation name. In Graphs 2.0, we have three distinct data types: Datasets, Generated Datasets and Equations.

Datasets are the regular, imported data that you all know and love. Nothing really has changed here. Generated Datasets are essentially the same as regular datasets, but the difference is that these datasets are generated from an equation. They work the same as regular datasets, but for generated datasets you can change the equation, step size and the limits after creating the item. Finally, the major new addition is the concept of equations. As the name implies, equations are generated based on an equation you enter, but they span an infinite range. Furthermore, operations you perform on equations are done analytically. Meaning if you translate the equation `y = 2x + 3` with 3 in the y-direction, it will change to `y = 2x + 6`. If you perform a derivative, the equation will change to `y = 2x` etcetera. This is a long-requested feature, and has been made possible thanks to the magic of sympy and some trickery on the canvas. Below, there’s a video that demonstrates these three data types.

Revamped Style Editor

We have redesigned the style editor, where we now show a live preview of the edited styles. This has been a pain point in the past, when you edit styles you cannot see how it actually affects the canvas. Now the style editor immediately tells you how it will affect a canvas, making it much easier to change the style exactly to your preferences.

We have also added the ability to import styles. Since Graphs styles are based on matplotlib styles, most features from a matplotlib style generally work. Similarly, you can now export your styles as well making it easier to share your style or simply to send it to a different machine. Finally, the style editor can be opened independently of Graphs. By opening a Graphs style from your file explorer, you can change the style without having to open Graphs.

We also added some new options, such as the ability to style the new error bars. But also the option to draw tick labels (so the values) on all axes that have ticks.

A screenshot of the Graphs style editor, on the left you can see the different settings as in the previous version. On the right you can see the live preview — The revamped style editor

Improved data import

We have completely reworked the way data is imported. Under the hood, our modules are completely modular making it possible to add new parsers without having to mess with the code. Thanks to this rework, we have added support for spreadsheets (LibreOffice .ods and Microsoft Office .xlxs) and for sqlite databases files. The UI automatically updates accordingly. For example for spreadsheets, columns are imported by the column name (alphabetical letter) instead of an index, while sqlite imports show the tables present in the database.

The new import dialog for Graphs. You can see how multiple different types of items are about the be imported, as well as new settings — The new import dialog

Furthermore, the import dialog has been improved. It is not possible to add multiple files at once, or import multiple datasets from the same file. Settings can be adjusted for each dataset individually. And you can even import just from a single column. We also added the ability to import error-bars on either axes, and added some pop-up buttons that explain certain settings.

Error bars

I mentioned this in the previous paragraph, but as it’s a feature that’s been requested multiple times I thought it’d be good to state this explicitly as well. We now added support for error bars. Error bars can easily be set on the import dialog, and turned on and off for each axis when editing the item.

Singularity handling

The next version of Graph will also finally handle singularities properly, so equations that have infinite values in them will be rendered as they should be. What was happening in the old version, was that for equations with values that go to infinity and then flip sign, that the line was drawn from the maximum value to the minimum value. Even though there are no values in between. Furthermore, since we render a finite amount of datapoints, the lines don’t go up to infinity either, giving misleading Graphs.

This is neatly illustrated in the pictures below. The values go all the way up to infinity like they should, and Graphs neatly knows that the line is not continuous, so it does not try to draw a straight line going from plus to minus infinity.

The old version of Graphs trying to render tan(x). Lines don't go all the way to plus/minus infinity, and they also draw a line between the high and low values. — The old version of Graphs trying to render tan(x). Lines don’t go all the way to plus/minus infinity, and they also draw a line between the high and low values.

The upcoming version of Graphs, were equations such as tan(x) are drawn properly.

Reworked Curve fitting

The curve fitting has been reworked completely under the hood. While the changes may not be that obvious as a user, the code has basically been completely replaced. The most important change is that the confidence band is now calculated completely correctly using the delta-method. Previously a naive approach was used where the limits were calculated using the standard deviation each parameter. This does not hold up well in most cases though. The parameter values that are given are also no longer rounded in the new equation names (e.g. 421302 used to be rounded to 421000). More useful error messages are provided when things go wrong, custom equations now have an apply button which improves smoothness when entering new equations, the root mean squared error is added as a second goodness-of-fit measure, you can now check out the residuals of your fit. The residuals can be useful to check if your fit is physically correct. A good fit will show residuals scattered randomly around zero with no visible pattern. A systematic pattern in the residuals, such as a curve or a trend suggests that the chosen model may not be appropriate for the data.

The old version of Graphs with the naive calculation of the confidence band

The new version of Graphs with the proper calculation of the confidence band.

UI changes

We’ve tweaked the UI a bit all over the place. But one particular change that is worth to highlight, is that we have moved the item and figure settings to the sidebar. The reason for this, is that the settings are typically used to affect the canvas so you don’t want to lose sight of how your setting affects the canvas while you’re updating. For example, when setting the axes limits, you want to see how your graph looks with the new limit, having a window obstructing the view does not help.

Another nice addition is that you can now simply click on a part of the canvas, such as the limits, and it will immediately bring you to the figure settings with the relevant field highlighted. See video below.

Mobile screen support

With the upcoming release, we finally have full support for mobile devices. See here a quick demonstration on an old OnePlus 6:

Figure exporting

One nice addition is the improved figure export. Instead of simply taking the same canvas as you see on the screen, you can now explicitly set a certain resolution. This is vital if you have a lot of figures in the same work, or need to publish your figures in academic journals, and you need consistency both in size and in font sizes. Of course, you can still use the previous setting and have the same size as in the application.

More quality of life changes

The above are just a highlight of some major feature updates. But there’s a large amount of features that we added. Here’s a rapid-fire list of other niceties that we added:

- Multiple instances of Graphs can now be open at the same time
- Data can now be imported by drag-and-drop
- The subtitle finally shows the full file path, even in the isolated Flatpak
- Custom transformations have gotten more powerful with the addition of new variables to use
- Graphs now inhibits the session when unsaved data is still open
- Added support for base-2 logarithmic scaling
- Warnings are now displayed when trying to open a project from a beta version

And a whole bunch of bug-fixes, under-the-hood changes, and probably some features I have forgotten about. Overall, it’s our biggest update yet by far, and I am excited to finally be able to share the update soon.

As always, thanks to everyone who has been involved in this version. Graphs is not a one-person project. The bulk of the maintenance is done by me and Christoph, the other maintainer. And of course, we should thank the entire community. Both within GNOME projects (such as help from the design team, and the translation team), as well as outsiders that come with feedback, report or plain suggestions.

Getting the beta

This release is still in beta while we are ironing out the final issues. The expected release date is somewhere in the second week of may. In the meantime, feel free to test the beta. We are very happy for any feedback, especially in this period!

You can get the beta directly from flathub. First you need to add the flathub beta remote:

flatpak remote-add --if-not-exists flathub-beta https://flathub.org/beta-repo/flathub-beta.flatpakrepo

Then, you can install the application:
flatpak install flathub-beta se.sjoerd.Graphs

To run the beta version by default, the following command can be used:

sudo flatpak make-current se.sjoerd.Graphs beta

Note that the sudo is neccesary here, as it sets the current branch on the system level. To install this on a per-user basis, the flag –user can be used in the previous commands. To switch back to the stable version simply run the above command replacing beta with stable.

The beta branch on update should get updated somewhat regularly. If you don’t feel like using the flathub-beta remote, or want the latest build. You can also get the release from the GitLab page, and build it in GNOME Builder.