Talks and Events

Beach Party

Details will be announced later.

Better GTK+ and app development on Windows

Last year at GUADEC, Jussi Pakkanen talked about how the Meson build system's subprojects and wrapdb features enable easier app development on all platforms.

This year I will talk about how these features have matured and now allow GTK+ and GTK+ app development on Windows without needing extraneous steps, fragile build environments such as MSYS or Cygwin, or non-native toolchains such as MinGW GCC.

I will demonstrate how easy it now is to develop, debug, and profile your GTK+ apps with the tools that Windows developers expect to be able to use.

Breaking into and defending Linux – examples

Breaking into and defending Linux – examples

Building Flatpak apps with Buildstream

Building Flatpak apps with Buildstream

Building for humans: methods for improving usability

Building for humans: methods for improving usability

Building the Libre Desktop

System76 talks about their new Linux desktop manufactured in Denver, CO. Integrated with Pop!_OS, a Gnome-based distro, this desktop features open sourced concepts inside and out. In this talk, we share the struggles of building an open desktop and why open computer designs are important for an innovative future. In the end, we prove that you don’t have to compromise aesthetics, quality, and performance for freedom.

Cultural show & picnic

Details will be announced later.

Dealing with controversy - a practical guideline

GNOME is a pioneer in the desktop and beyond. Being in the pole position means that we invite criticisms in our online world both fair and unfair.

This talk will focus on how to deal with controversies, communicating effectively, and extracting relevant feedback to controversial issues while maintaining your sanity

Design of an UX case: IoT integration in GNOME.

The talk would be about a mockup and current ideas for a new user experience case design, integration of smart homes appliances and internet of things middleware in GNOME at a glance. Providing details of how successful could be GNOME the first UI for Linux that could integrate with such things like Google Assistant, Alexa, Cortana, IFTTT, or appliances like Philips Hue and NeXT. By likely integrating the Google Assistant SDK directly in GNOME, making GNOME a more human experienced and native language experienced GUI for the Linux Environment.

Designing GNOME Mobile

Purism's Librem 5 is the first phone built from the ground up to respect user freedom and privacy. It will run PureOS, a real GNU/Linux distribution, and use GNOME as its user interface. But how is that possible? GNOME doesn't run on phones, does it?

Well, not quite yet, but at Purism we're working on changing that. In my role as designer on the Librem 5 project I'm adapting the design of existing GNOME apps to the phone form factor, and designing new apps from scratch. We want as much of this work as possible to go upstream, in order to benefit all GNOME users.

In this presentation I'll show some of the progress we've been making, and talk about how to design GNOME apps that work well across different form factors.

DevOps for GNOME

As you probably might know, GNOME hasn't been the most updated in technologies & processes used for the design, development, testing, QA, delivery loop. To be honest, we have been quite behind!

Build fails, not passing tests, contributors stuck with trivial details, each product with different released days, designers and QA in need to build the whole stack to try out a minimal UI change… well, we could continue indefinitely. Needless to say this was a huge impact in our performance and contributor friendliness, even more in a time where web applications are as common.

Fortunately, things have changed dramatically over the last two years, specially with Flatpak for a containerized-alike build and distribution of apps and our move to GitLab and its integrated CI, we are able to fully dive into integrating a more DevOps oriented workflow. This effort has become a dream come true for GNOME, that we would have never imagined a few years back.

In this talk I will present and explain in details how to use and integrate Flatpak and GitLab together to create the future of the DevOps experience for Linux applications development and how we use it at GNOME and what impact is making to our organization.

Download management on metered connections

Endless OS is often run on machines where internet connectivity is metered: the user has to pay per unit of bandwidth used. Due to the variety of tariffs available, reducing the bandwidth cost of important downloads (such as OS updates) to the user is non-trivial. We’ve implemented a scheduling system for downloads to address this. It has uses on regular laptops too, allowing downloads to be deferred until you’re back home and not using mobile data.

This talk will provide an introduction to download management and how we see it being used in future.

Endless Code

Endless Code

Flathub - An app store and build service for…

Talk title (complete): Flathub - An app store and build service for flatpak applications

Since last year's launch, Flathub has become the de facto app store for flatpak applications, with hundreds of available apps and thousands of monthly users.

This talk will provide answers to the following questions:
- What is Flathub? What does it offer users and developers?
- How can I publish a new app/theme/runtime/...?
- How does Flathub work? What is the infrastructure behind it (build service, website...)?
- What plans are there for future development?
- How can I contribute to Flathub?

Flatpak workshop

Available spaces: 48 on a first come, first serve basis
Pre-requisites: laptop with flatpak and flatpak-builder installed

Learn the basics of flatpak package and some tricks and tips for developing with flatpak. The workshop starts with me talking about an hour, and then you can bring your own application to package. David and I will help people out and bring up common pain points for discussion. If you're only interested in the talk part that is fine too.

Freedesktop-sdk, the future of Linux runtimes

The freedesktop-sdk was originally started as a Flatpak subproject to create a minimum Linux baseline. It’s now a separate project hosted on freedesktop.org, and is used as the foundation of GNOME releases. The long term goal of the project is to maintain a neutral baseline which can be consumed by Flatpak, GNOME, KDE and others.

This talk will focus on the recent work to upgrade and modernize the sdk. We will discuss what the project has done so far, including the benefits of improved automation and converting the format entirely to BuildStream (rather than several different metadatas).

We will also talk about what we are doing next and why all of this matters to GNOME.

GLib: What’s new and what’s next?

A look at recent activity in GLib, current development, and plans for the future.

GNOME Foundation AGM

The annual general meeting of the GNOME Foundation

GNOME Foundation: Looking into the Future

Exciting things are afoot! Come hear the plans for what is to come in the GNOME Foundation.

GTK4 Lightning talks

The GTK team has been hard at work improving the core of the toolkit.

This talk will present all the internal subsystems that have seen changes in the form of lightning talk sized chunks, so that by the end of the talk you know about things such as GtkMotionController, GskRenderer, GtkSnapshot, GdkPaintable or GtkMediaStream.

Have you ever developed for a GPU?

You have probably heard about GPUs and OpenGL and seen the wonders that are possible with them. So has the GTK team. But what the GTK team hadn't heard about were the traps and pitfalls you have to carefully navigate around to make those wonders happen.

This talk will present what we learned so that you already have a head start when you decide to use the magic of GPUs.

How I secretly wish fonts worked (on GNOME)

How I secretly wish fonts worked (on GNOME)

How to handle design critique

How to handle design critique

Implementing Phone UIs with GTK+

Implementing Phone UIs with GTK+: Tips and Tricks

Input methods, wayland, and upstreams

Input methods, wayland, and upstreams

Intern and newcomer lightning talks

Lightning talks presented by Google Summer of Code and Outreachy interns, and newcomers to GNOME. If you are a newcomer and would like to present a lighting talk, please e-mail <a href="mailto:kat@gnome.org">Kat</a>

Javascript in GNOME in 2018

This talk is about all the improvements made in GNOME's Javascript platform in the past year. We've made many strides: developer experience, especially for new contributors; new Javascript language features; and performance improvements, especially in memory usage. I'll talk about the improvements and how they affect the four audiences: users, app developers, GNOME Shell developers, and shell extension developers. I'll also talk about some projects that we need your help with!

Lightning talks

Fast-paced and focused talks on any and all subjects. All talks will be subject to a strict time limit of 5 minutes on stage (including setup). Slides are welcome, but not compulsory.
You will be able to sign up for a lightning talk slot on the day. Talks will be accepted on a first come, first serve basis.

Making a phone call with GNOME

The journey toward making GSM calls on the upcoming Librem 5 phone using the GNOME platform. An exploration of the issues encountered, the current status of our Calls application and discussion of intended future work.

Maxwell: embedding widgets in WebKit

Maxwell is a proof of concept library that extends WebKitWebView to let you embed/pack Gtk widgets in it using good old GtkContainer API.

Inspired by Broadway, Maxwell renders all its children in an offscreen window and integrate them into the DOM tree by drawing on a HTML5 canvas element.

In this talk we go trough the juicy part of the implementation details, a few test cases and a real world application of the library.

Migrating from JHBuild to BuildStream

JHBuild has served GNOME developers well for over a decade, but it is not very reliable and has caused many problems for newcomers attempting to build our software with it. This talk will present BuildStream, a new system for reliably building all of GNOME, and compare it to JHBuild. The focus will be on helping developers who are already familiar with JHBuild migrate to using BuildStream instead. Advantages and disadvantages of BuildStream relative to both JHBuild and flatpak-builder will be discussed.

This talk will also introduce gnome-build-meta, the new official source for GNOME build definitions, which is intended to obsolete the JHBuild modulesets, the GNOME Continuous manifest, and the manifest used to build GNOME's Flatpak runtimes.

Miracast for GNOME

Miracast is a standard that allows streaming video and audio content over WiFi connections. This can either work on a local network (i.e. when connected to an AccessPoint or Infrastructure network) or through a direct P2P connection (WiFi-Direct) to a miracast enabled dongle.

This talk will give an overview of the progress made so far to support such devices on GNOME. While this work builds on miraclecast (https://github.com/albfan/miraclecast) a number of improvements throughout stack are required to make these devices easily usable to users.

Note: Most of the work for this talk has not yet happened. I expect that at least a number of the core integration issues will be solved by GUADEC and a proof of concept can be demonstrated.

Open talk

You can submit proposals for 20 minute slots for talks, discussion panels and presentations in other formats. The presentation with most votes from attendees will be selected at 14:20 each day to be presented at 15:00 or 15:30.
This is your chance to present cutting edge developments or anything that did not make it into the normal schedule.

P2P Distribution of Flatpaks and OSTrees

Endless is empowering the world by bringing the computing revolution to the people that have been left out due to the barriers of cost and connectivity, and this mission is only made possible by GNOME and other free software. One of the ways we're working on making computers useful in conditions of limited or nonexistent Internet connectivity is by allowing apps and OS updates to be distributed in a P2P way, over USB drives and local networks. This feature has required significant changes to both OSTree and Flatpak, two of the technologies that underlie Endless OS. We're planning to roll out the feature this summer, and this talk will focus on both the technical aspects and the user needs that motivated the work.

Patterns of refactoring C to Rust

Last year I gave a talk on *why* it was desirable to port librsvg from C to Rust. That talk showed cool things about the Rust language, mostly centered around expresiveness and memory safety.

This time, I want to show you *how* the librsvg team (we have a team now!) has been doing the port, gradually, steadily, without breaking client applications. We will present common patterns that show up when refactoring C to make it easy to port to Rust. We'll show how the first pass at Rustification works, but it is ugly - but how a second pass can turn it into beautiful, idiomatic Rust code. We'll show how C code with no error handling can be turned into Rust code that checks and propagates errors thoroughly.

The hope is to show that we can give the low-level GNOME platform another 20 years of life by porting it to a better low-level language.

PipeWire

PipeWire is a modern graph-based multimedia processing engine that aims to make it possible to exchange content between applications and devices. It builds on concepts from many different sources such as GStreamer, JACK, CoreAudio, Pulseaudio, Wayland and LV2.

In this talk we will briefly go over the current state of PipeWire. The remainder will consist of a demonstration of the audio and video processing capabilities and will show how the integration of Desktop and Pro audio can be achieved.

Plan your testing

GNOME has seen a number of initiatives to improve testing over recent years and the project is in the best position to see further improvements. Automated testing, especially with the move to GitLab, is more effective than ever. Usability testing has seen a lot of work from Jim Hall and the design team. But what about the planning and organisation around delivering GNOME as a product?

I will discuss the theory and processes around planning testing for a product like GNOME with regular releases, using real life examples from Apertis and how they can be applied to applications and the GNOME desktop. I will discuss the pros and cons of different approaches and how to decide what you should be using.

Product Management in Open Source

What role does Product Management and other non coding roles play within open source and GNOME? Inspired by an excellent blog post from Christian Hergert this will talk about cherishing and encouraging non coding roles within GNOME. I'll cover what Product Management is and how it can help with some of the challenges the community is facing.

Simple tricks to assess and improve the security o

We have powerful tools such as Address Sanitizer and american fuzzy lop at our disposal. Together with the reproducible build in clean environments that flatpak provide, we can shake bugs out of our apps as easily and efficiently as never before. In this talk, I will demonstrate how to build an app such that the potential of the security related tools is maximised, how to interpret results, and ways forward to improve the security of all (self compiled) flatpak apps and thus the wider ecosystem, hoping to make GNOME a leader in the field of secure app delivery.

Slimbook Linux laptops

Slimbook Linux laptops

Snap Package support in GNOME

Snap Package support in GNOME

The infamous GNOME Shell performance

Over the past year, there has been lots of things going on related to GNOME Shells performance and memory consumption, including a hackfest in Cambridge, UK, in the middle of May. This talk aims to summarize what has happened lately within these topics, and what will happen in the future.

Thunderbolt, GNU/Linux and GNOME

Thunderbolt 3 is a relatively new technology to connect peripherals to a computer. Because it can access the computer's resources directly, it allows for very high speeds: it is fast enough to drive external graphics cards.
However, the mechanism that allows these high speeds also poses a security risk because malicious devices could obtain sensitive information from the computer's memory.
Version 3 of the Thunderbolt interface therefore provides security levels in order to mitigate the aforementioned security risk that connected devices pose to the system. As a result, devices need to be authorized manually. The talk aims to provide an overview of the Thunderbolt technology and will try to clarify some of the confusing aspects, e.g. the many modes and features of the USB type C connector that Thunderbolt 3 uses. Finally, the talk will show how some tricky user experience problems were solved, with a focus on the integration with GNOME.

Translating software using related languages

Intended audience: translators, current and aspiring l10n team leaders

Summary:
Translating a big software project like GNOME is hard, especially for small teams. However, if the target language is related to another language that already has good coverage, the translation can be done much faster. In this talk I will explain the word substitution translation method and the new tool that implements it for GNOME translation files, mt-words.

Talk overview:
- Currently available tools for software translators
- Machine translation approaches used in general
- Detailed overview of the word-substitution method,
including its strengths and which languages could use it
- What makes software interfaces easier and harder to translate
- Why word substitution translation is suitable for GNOME
- Presenting my translation script “mt-words”, an overview of how
it addresses the issues with translating .po files
- Case study: translating parts of GNOME from Latvian to Latgalian
* preparing the source language text
* writing the translation script
* creating the dictionary and terminology
* editing the final translation
- Overview of how to maintain translations; what to do if:
* the original English string changes
* the related language string changes
* a dictionary record changes

Ubuntu's journey from Unity to GNOME Shell

Since 2011, Ubuntu had shipped Unity as the default shell for Ubuntu. In 2017 the decision was made to transition from Unity to GNOME Shell as the default experience for Ubuntu. We made the transition and shipped GNOME Shell by default in 17.10, with a slightly modified default experience. We've since shipped GNOME Shell by default in 18.04, our latest LTS release.

We'll talk about how we tackled this transition, obstacles we encountered and how we dealt with them. We'll also present current challenges and what we hope will be a solid path forward.

What's happening in Builder?

This year we'll discuss what has and hasn't been working well in Builder and what we're doing to address it.

As usual, there will be plenty of demos and tips for how to use Builder more efficiently.

Lastly, an overview of various plugin API will be provided to help GNOME contributors join in improving our tooling.