KDAB talks at Qt World Summit 2019

The agenda is published and KDAB engineers are offering a wealth of technical talks this year.

From time to time, however, we may face performance problems in our UI layer, especially in constrained hardware environments (mobile or embedded). In order to tackle these problems we need to understand the foundations of Qt Quick 2’s rendering, and how to design our code in order to extract the maximum performances from the underlying hardware.

And while it is true that premature optimization is the root of all evil, avoiding premature pessimization is also extremely important, especially at early stages of design of a complex application.

In this talk we will introduce the main principles behind profiling and optimizing the rendering of a Qt Quick 2 application.

We will start by discussing how Qt Quick 2 renders a scene – namely, through its scene graph and via OpenGL calls.

We will see how to gather information about how effectively Qt Quick is rendering a scene. Some of this information is available via “secret switches”, while other requires the usage of external tools, which is therefore necessary to master.

Finally, we will discuss how to fix some of the most common performance problems: poor batching, excessive overdraws, fill rate limitation, and poor texture memory utilization.

Practical experience with QML application is required, and some OpenGL knowledge is beneficial (but not necessary).

One of the techniques used to improve the security of such code is fuzzing.

Fuzzing involves providing invalid or random data to a given piece of code to test its behaviour.

Modern fuzzers are smart enough to understand what needs to be changed in the input to make the code go through a different code path making testing faster and more complete.

oss-fuzz is a Free set of tools to make fuzzing of C/C++ code easier.
It is comprised of various scripts and docker images, which, for example, have the base system libraries already compiled with the sanitizers.

Coupling a fuzzer with the compiler sanitizers (asan, ubsan, msan) gives even better results since these sanitizers will make sure the code is run more strictly.

In this session we'll show how to fuzz a C++ codebase, as well as give you an update on how Qt is using these tools.

But how do we deal with back-ends that don’t deliver enough data to do this? What if they just signal ‘changed’ or give us a whole new list without indicating what changed?

Instead of relying on repetitive, hard-to-read and error-prone code or in the worst case relying on a model reset, I will present a generic approach leading to a simple drop-in solution to deal with data that comes in in bulk which results in proper, finely-grained updates to the model. A similar problem is providing all needed signals in case the model needs to be sorted. While a QSortFilterProxyModel does a good job doing the actual sorting, it does not provide the required signals to allow animating items moving in a QML ListView when the value of items changes or when the sort role or -column changes. In order to fix this, I will present a specialized proxy model that does enable this.

Using these tools will help you make your models behave like "model" models.

QML Component Design: the two-way binding problem, André Somers

Did you ever create QML components that both display and manipulate a state that is stored in some kind of back-end? How do you ensure a property binding set by the user of your component stays intact? What should happen if that backed is slow, or rejects your changes?

In this talk, we will explore this problem in some more detail, and demonstrate a few possible solutions that deal with the challenges raised in different ways. The goal is that at the end of this talk, you will have the tools available to make UI components that behave predictably and are intuitive to use in your applications.

This talk will introduce you to several highly valuable tools backed by Clang, such as the Clang compiler frontend itself (for static analysis), the Clang static analyzer (for static analysis), clang-tidy (for static analysis, linting & refactoring of source code), clang-format (for enforcing a coding style on your code), Clang Sanitizers (dynamic analysis) and last but not least: Clazy (a compiler plugin for Clang that has additional checks for Qt code).

For each tool in this presentation, we'll do a brief introduction about its capabilities and then live-demonstrate its usage on a few code examples. We'll also demonstrate how the Clang tools can be used on projects using build systems other than CMake, by applying a few tricks.

Clang is available on all major platforms, thus these tools can be used freely on either Windows, Linux or macOS. (With some limitations of the Clang Sanitizers on the Windows platform).

Git and Gerrit for working with and on Qt, Kevin Funk

A basic knowledge of Git is essential if you want to apply patches back to Qt or try out a not yet released version of Qt. In this talk we're going through the most basic bits about modern software development with the code version control system Git. Beginning with the basic concepts, such as the initial setup, checking out code we will show how to manage and commit changes as well as navigate through the Git history.

Building on that knowledge, we'll demonstrate doing exactly the same using the Git integration inside the QtCreator IDE, which provides similar functionality via a convenient graphical interface.

After having done that, we will show how to get started with the code review system in place for the Qt ecosystem, Gerrit. As part of this talk we'll discuss how to set up your Gerrit account, how to upload your SSH keys and how to configure your Git checkout to be ready to work with Gerrit. We'll do a small change on Qt module checkout, verify we did not break existing functionality, and then submit our change for review.

This talk will present that part of the framework, show how it is used and discuss possible ideas of how that could be extended to target completely different type of features in the future.

What's new in KUESA and Qt 3D, Paul Lemire

Various things have been overhauled and improved in both KUESA and Qt 3D over the past year. This talk is about showing what has changed and defining where we'd like to go with both KUESA, the designer-developer workflow package, and the Qt 3D module.

In this talk, we will discuss the strategy and steps to migrate a MFC legacy code base to Qt, how to map MFC code to Qt, as well as some of the traps to avoid.

The format will be a series of live-demos with Qt applications which either have been extended with such a scripting environment or which have even been built specifically around this capability.

Similar to the original talk the goal is to show once again that QML is a versatile and powerful component for all Qt application development, above and beyond the already established use case of building advanced UIs.

There are many good and valid answers to these questions. Tracing certainly is a very
valuable addition to everyone's toolset. It can offer in-depth insights into what a system is doing and why an application is performing in a given way. Done properly, we can use it to piece together multiple pieces of the picture: How is our hardware utilized, what is the kernel doing, what is my application doing?

In this talk, we will give an introduction to LTTng, a tracing toolkit for Linux, and show how it can be applied on embedded Linux systems to get an answer to the following question: What can I do to optimize the startup time of my application?

We will talk about configuring Qt and LTTng properly. We will discuss the most useful kernel trace points and demonstrate the tracing subsystem in Qt for custom user space trace points. And we will look at how to analyze the collected data in a way that doesn't make you want to pull your hair out.

The contents of this talk stem from the experience of successfully optimizing automotive Qt applications on embedded Linux applications. The lessons learned apply to a much broader audience and can also be used with other tracing toolkits such as ETW on Windows.

If you do string processing with Qt, this talk is for you. After a very brief recap on QStringView's general purpose in Qt, we will look at what's new in Qt 5.14 with respect to QStringView and, time permitting, take a brief look into the near future.

Especially for Embedded Devices, offering remote monitoring, configuration or off-site maintenance adds benefit to users used to mobile and opens quick paths for support-teams to help effectively.

This talk will summarize all options Qt has to offer for these needs and the usual paradigms to follow when you design your software to reach out further.

See the full agenda here.

Check out the Training courses on the 4th and sign up for Qt World Summit 2019.