Qt World Summit, organized by The Qt Company, is the premier Qt event of the year and follows on from Qt Developer Days that KDAB organized in the years 2012–2014. KDAB has been and continues to be a major sponsor and contributor to the event. Our experts give many of the in-depth technical presentations and we run the popular pre-conference trainings.
KDAB 20 Years Ahead
KDAB reached 20 years in November 2019 and on the evening of November 5th, we invited Qt World Summit attendees to celebrate with us. KDAB management offered free craft beer to all attendees and a great deal of fun was had by all. Find out more about KDAB’s 20 Years ahead…
KDAB Talks at Qt World Summit
KDAB engineers contributed fourteen expert talks on subjects including C++, Qt, Qt 3D, Tooling, QML, Migration and more:
- Optimizing the Rendering of Qt Quick 2 applications – Guiseppe D’Angelo
- Testing your code for security issues with automated fuzzing – Albert Astals Cid
- Model models: tools for making better behaved models – André Somers
- QML Component Design: the two-way binding problem – André Somers
- Improving your code using Clang Tooling – Kevin Funk
- Git and Gerrit for working with and on Qt – Kevin Funk
- Qt 3D Node Editor and Shader Generator – Paul Lemire
- What’s new in KUESA and Qt 3D – Paul Lemire
- Migrating from MFC to Qt – Nicolas Arnaud-Cormos
- Practical application scripting with QML – Kevin Krammer
- Full-stack Tracing With LTTng – Milian Wolff
- QStringView — Past, Present, and Future – Marc Mutz
- Testing & Profiling Qt on Android – Bogdan Vatra
- Qt on the second Screen – Christoph Sterz
You can see them all below, and the rest of the talks are available here.
Optimizing the Rendering of Qt Quick 2 applications, Giuseppe D’Angelo
If you have ever wondered how Qt Quick applications are rendered to the screen, and how to use that knowledge to find and fix performance problems, then this talk is for you.
Qt Quick 2 applications are notably easy to write. With just a few lines of QML code we can create compelling, animated, fluid, 60FPS user interfaces.
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.
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). View the slides…
Testing your code for security issues with automated fuzzing, Albert Astals Cid
Writing secure code that deals with potentially untrusted data (parsers, importers, etc) is always hard since there are many potential cases to take into account.
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. View the slides…
Model models: tools for making better behaved models, André Somers
Qt QAbstractItemModel API is used for both widgets and QML applications where it plays a central role for cases where there is a need to present larger quantities of data. For optimal performance, UI experience and to be able to use the insert, remove, move and displaced transitions on the QML ListView it is imperative that updates are signalled properly and as finely-grained as possible. 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. View the slides…
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. View the slides…
Improving your code using Clang Tooling, Kevin Funk
Clang is a C/C++ compiler frontend which parses C++ source code. Since the beginning of its development, the Clang ecosystem had a strong focus on providing tooling around C++. Several tools exist, which help writing or debugging C++ or even Qt code.
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). View the slides…
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. View the slides…
Qt 3D Node Editor and Shader Generator, Paul Lemire
>More and more frameworks and tools are providing higher level of development through the use of Node Editors to create code, behaviors or entire applications.
Since Qt 5.12, Qt provides support for loading a tree of nodes and convert these to generate OpenGL GLSL shader codes for Qt 3D.
This can be harnessed to create a single shader description that can then be translated into different languages.
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. View the slides…
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. View the slides…
Migrating from MFC to Qt, Nicolas Arnaud-Cormos:
Microsoft Foundation Class Library (MFC) is a legacy C++ object-oriented library on Windows that exists since the dawn of Windows. It has been replaced lately with more up to date framework, but MFC legacy code still widely exists.
While Qt and MFC are both over 25 years old, that’s where the similarity ends. Qt is actively maintained by a vibrant developer community, upgraded regularly to embrace the latest programming improvements, and expanded to cover new devices and operating systems. Qt is then a natural candidate for replacement of MFC.
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. View the slides…
Practical application scripting with QML, Kevin Krammer
In my talk “When all goes according to script” at Qt World Summit 2015, I explored the fundamentals of using the QML environment for the purpose of in-application scripting.
In this follow-up I am going to look into more practical aspects, especially on how the powerful declarative approach in QML allows very easy handling of asychronous scripting tasks.
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. View the slides…
Full-stack Tracing With LTTng, Milian Wolff
We all love and use C++ because of its performance. But how do we actually measure the performance of an application? How do we check whether an application is CPU- or I/O bound? How do we see if our application is influenced by others running on the same system?
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. View the slides…
QStringView — Past, Present, and Future, Marc Mutz
Since QStringView was added in Qt 5.10, not much has happened, and the presenter duly asks for forgiveness for having stepped away from QStringView development for two years. But he’s back now, and Qt 5.14 will contain a significantly more complete QStringView (and QLatin1String) ecosystem than 5.13 did.
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. View the slides…
Testing & Profiling Qt on Android, Bogdan Vatra
In this session we are going to learn how to test and profile our Qt application on Android.
The talk will cover:
- how to use Qt Test on Android
- how to use Google tools to do profiling
Qt on the second Screen, Christoph Sterz
Companion Apps, VNC remoting, streaming WebGL to the Browser or compiling your Code to WebASM – Adding a secondary screen to your application can either extend its functionality or the physical range for users operating it.
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. View the slides…
KDAB demos at Qt World Summit
KDAB was the main sponsor and showed our latest top-class demos at our booth:
- Speidels Braumeister – full stack: a UI and process control for Braumeister’s world-renowned home brewing kit for which KDAB provided full stack support using QML.
- unu: Dashboard for Electric Scooter: with a navigation framework integrated with Qt Quick scene
- KUESA Qt & Qt3D Realtime Music Box: a robot arm controlling a music box with animation imported from Blender via GLTF2
- KDAB Tools: three of KDAB’s renowned developer tools: GammaRay, the high-level introspection tool for Qt apps, Clazy, static code analyzer and Hotspot profiler.
- QiTissue: built on top of Qt Widgets, QGraphics View, Qt Quick and Qt 3D, this application lets cancer researchers visualize in 2D and 3D from gigabytes of data.
Read more about KDAB’s demos at Qt World Summit Berlin, 2019
Both unu, the Berlin-based mobility company and Braumeister, were Customer Showcases for KDAB and Qt at Qt World Summit in Berlin, 2019. Attendees were able to see the latest model of the unu electric scooter at the event, and a brand new Braumeister home brewing kit at our booth.
KDAB Training Day, Nov 4
These are the one-day training courses we offered. Check out the detailed descriptions here.
- Introduction to Qt3D Studio
- Introduction to CMake
- Introduction to QML
- Multithreading in Qt
- Qt GUI Testing with Squish (provided by our training partner, froglogic)
- Profiling & Debugging for Linux
- What’s New in C++17?
- Modern OpenGL: Advanced Pipeline and Performance
See the film we made for KDAB Training Day in 2019…