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 the main sponsor and contributor to this event in Europe, the USA and Asia. Our experts give many of the in-depth technical presentations and in Berlin we run the popular pre-conference training day.
Qt World Summit 2019 – Berlin, Nov 4-6
KDAB Talks at Qt World Summit
KDAB engineers contributed fourteen expert talks on subjects including C++, Qt, Qt 3D, Tooling, QML, Migration and more:
Conference Day 1 – November 5th
- 14:00 – QStringView — Past, Present, and Future – Marc Mutz
- 14:30 – QML Component Design: the two-way binding problem – André Somers
- 15:00 – Practical application scripting with QML – Kevin Krammer
- 16:00 – Model models: tools for making better behaved models – André Somers
- 16:30 – Migrating from MFC to Qt – Nicolas Arnaud-Cormos
Conference Day 2 – November 6th
- 11:00 – Testing your code for security issues with automated fuzzing – Albert Astals Cid
- 11:30 – Improving your code using Clang Tooling – Kevin Funk
- 13:30 – Optimizing the Rendering of Qt Quick 2 applications – Guiseppe D’Angelo
- 13:30 – Full-stack Tracing With LTTng – Milian Wolff
- 15:00 – What’s new in KUESA and Qt 3D – Paul Lemire
- 15:00 – Git and Gerrit for working with and on Qt – Kevin Funk
- 15:30 – Qt 3D Node Editor and Shader Generator – Paul Lemire
- 16:30 – Qt on the second Screen – Christoph Sterz
- 16:30 – Testing & Profiling Qt on Android – Bogdan Vatra
Talks will be published by The Qt Company in due course and we will post them here too.
KDAB demos at Qt World Summit
As the main sponsor, KDAB had a large booth with our latest top-class demos:
Speidels Braumeister – full stack
unu: Dashboard for Electric Scooter
KUESA Qt & Qt 3D Realtime Music Box
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…
We’re delighted that 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. Read more about unu…
KDAB Training Day, Nov 4
These are the one-day training courses we offered on November 4th at the Berlin Congress Centre. Check out the descriptions below.
Introductory Courses at Qt World Summit 2019
- Introduction to Qt3D Studio
- Introduction to CMake
- Introduction to QML
- Multithreading in Qt
- Qt GUI Testing with Squish (provided by our training partner, froglogic)
Advanced Courses at Qt World Summit 2019
- Profiling & Debugging for Linux
- What’s New in C++17?
- Modern OpenGL: Advanced Pipeline and Performance
See more about KDAB training and our Training Day…
Introductory Course descriptions
Introduction to Qt 3D Studio, trainer: Nuno Pinheiro
This training introduces designers and developers to 3D content workflows and concepts, giving them a solid grounding in creating content using Qt 3D Studio, achieving the visual results they require, and integrating their work with other Qt content such as Qt Quick.
Existing 2D and 3D designers, user-experience designers, as well as developers working on visuals, will all benefit from learning the features and workflow offered by Qt 3D Studio. The training includes a large amount of hands-on time with the software, giving students confidence to begin creating their own content immediately, taking full advantage of the core features available.
Why learn Qt 3D Studio?
Qt 3D studio gives a tool-led workflow for integrating 3D content into Qt and QtQuick. It provides a simple environment for structuring 3D content, defining animations and behaviors, specifying materials and visual effects, and exporting complete presentations to an optimized runtime component.
While a wide range of workflows are possible when integrating 3D content, this training allows you and your team to focus on the best-practice approaches when working with Qt 3D Studio, to give a robust and well-defined path from 3D content into your final product.
Target audience: Principally designers, or developers who need to get an overview of QML integration. Prerequisite: No coding experience required, some familiarity with 3D concepts would be useful.
Senior UX/UI designer at KDAB, Nuno did the first QML training for designers and actively uses the QML language for fast UX/UI prototyping and UI solutions deployment. His works include general illustrations, UI design, corporate design, interactive mock-ups, animation examples and much more. Known for his contribution to the award winning Oxygen Project where he is the current coordinator, his computer art is used on KDE computer platforms worldwide. Nuno has an MSc in Civil Engineering.
Introduction to CMake, trainer: Kevin Funk
CMake is the de facto standard build system for C and C++ outside of frameworks that require their own. It has earned this place by supporting the situations and special cases that arise in real projects.
Support for CMake within Qt is being significantly improved and there are longer term plans to switch to CMake for building Qt itself. It’s currently a good alternative if you hit limitations in qmake.
This course will teach the basics of creating and building projects with CMake. In recent years, CMake has introduced some cleaner and more precise constructs. The course will focus on the new constructs where possible.
Why learn CMake?
CMake has broad functionality that covers many real world problems. Learning CMake enables you to solve advanced build requirements. This includes cross-platform builds, feature detection based on platform or available libraries, built- time configurable feature switches and custom build steps. CMake is increasingly widely adopted across the industry.
Target audience: C and C++ Developers who are interested in how to build their code. Prerequisite: Experience with build systems.
Kevin has actively developed with Qt/C++ since 2006 and has a special interest in tooling and profiling. He’s an active contributor to KDAB’s GammaRay analyzer (a high-level Qt application debugger) and has a strong emphasis on state machine tooling. He is co-maintainer of the KDevelop IDE, a powerful C/C++ development environment backed by Clang, and is pushing for cross-platform success inside KDE. Kevin holds a Masters Degree in Computer Science.
Introduction to Qt/QML, trainer: Jan Marker
This training is an introduction to Qt Quick. On the one hand it will teach you how to compose fluid user interfaces with slick animations using the QML language. On the other hand it will teach you how you hook the QML side up to your business logic in C++.
- Course contents:
- Connecting a QML UX with C++ business logic
- Complex list views including data provided from C++ models
- Custom objects implemented using Qt Quick scene graph
- Profiling and best practices for optimal performance
Why learn Qt QML?
Designed to take people new to Qt or QML, from the basics to a deep functional understanding of best practices, this Qt/QML training will equip you with the skills and know-how to boost your productivity at work.
Target Audience: Developers and managers interested in learning the autonomy of a QML application. Prerequisite: Knowing the basics of Qt at C++ level is an advantage but not a requirement.
Software engineer at KDAB, Jan has been using Qt since 2009 when he started contributing to the KDE project. Since joining KDAB he has worked on multiple large Qt and QML projects, while more recently also developing Wayland compositors. Besides in-depth knowledge of Qt and C++, Jan also has a deep interest in other technologies like NodeJS. He holds a BSc in Computer Science.
Multithreading in Qt, trainer: András Mantia
Multithreaded programming is essential for developers to create fast and responsive applications on computers, phones and embedded devices, all with an increasing number of cores. Qt offers several mechanisms for multithreading; however, it can be difficult to know which to use and how to steer clear of common pitfalls. This course offers guidance for writing safe and efficient multithreaded code with Qt.
Why learn about Multithreading with Qt?
Multithreaded development is a complex subject where it is easy to write code that contains severe bugs yet looks correct. This training will provide a solid foundation for writing safe and effective multithreaded code in Qt applications.
Target audience: Qt Developers interested in multithreading programming. Prerequisite: Knowledge and experience programming with Qt and C++. A basic understanding of multithreaded programming is an advantage but not required.
Senior software engineer at KDAB. András has actively developed with Qt since 2002 and is a core developer of KDE’s web development environment Quanta Plus and contributor to other parts of KDE. He talks at free software events about Qt-based products and has held training courses for companies such as Accenture, TietoEnator and Nokia.
Qt GUI Testing with Squish, trainer Jakub Topolski, froglogic
In order to achieve high quality applications during testing process all the functionality of the software shall be covered, including fully exercising GUI itself. For regression testing automating this process gives benefits, saving execution time and increasing accuracy. On the other hand, GUI Automation might be a challenge, as GUI may change significantly during a product life cycle. In this course we learn how to design and implement cross-platform automated tests using Squish GUI Tester for Qt, QML & QtQuick applications that continue to work as your product evolves.
You will learn:
- Introduction to GUI Testing
- Squish Overview (installation, configuration)
- Test Script Creation and Execution
- Recording and Replaying Test Scripts
- Verification Points (Properties, Screenshot, Visual)
- Test Results and Logging
- Squish API
- Image-Based Lookup
- Development of Test Cases at Business Level
- Set-Up and Tear-Down Functions
- Debugging Test Scripts
- Object Recognition
- Accessing Application Internals (Inspecting, Object Properties and Methods)
- Synchronisation and Event Handling
- Squish Command-Line Tools
- Working with Multiple Applications
- Hooking into Running Applications
- Squish Integration with CI
Prerequisites: The course is for developers and testers already familiar with the basic concepts of Qt.
Jakub has worked in Quality Assurance since 2012. Over the years he has gained experience in manual, automatic and performance testing. A Python enthusiast, Jakub joined froglogic in 2016 to support Squish users, conduct trainings and consult. He graduated from the Gdansk University of Technology with a BSc in computer science.
Advanced Course details
Modern OpenGL: Advanced Pipeline and Performance, trainer: Giuseppe D’Angelo
This training explores strategies to increase the performance of new and existing OpenGL code, with multi-pass rendering and use of uniform buffers, shader storage buffers and indirect drawing to reduce driver overhead.
Why learn about advanced pipeline and performance?
Getting the best from available hardware resources, especially on constrained systems, means deeply understanding the costs of different graphics operations, and how to optimise the rendering architecture to meet visual requirements. This course teaches how to increase performance effectively.
Target audience: Developers wanting to create or improve existing rendering code, using every technique at their disposal to understand and maximise performance, and extract the full potential from their hardware. Prerequisite: Developers already working with OpenGL, comfortable with the basics of specifying geometry, writing basic shaders and working with large image data.
An Approver of the Qt project and software engineer at KDAB, Giuseppe is a long time contributor to Qt, having used Qt and C++ since 2000. His contributions in Qt range from containers and regular expressions to GUI, Widgets and OpenGL. A free software passionate and UNIX specialist, before joining KDAB, he organized conferences on opensource around Italy. He holds a BSc in Computer Science.
Modern C++ – What’s New in C++17? trainer: Marc Mutz
At the end of 2017 the new C++17 standard was released, adding a sizeable amount of useful new features. All major compilers already support most (if not all) of these features.
In this training, the most useful of the new features introduced in C++17 and its predecessor will be presented. In cases for which these features depend on features introduced in C++11 or C++14, these will be refreshed as well.
New library features being presented include the new types std::any, std::optional and std::variant, the new parallel algorithms, filesystem access, std::string_view and new operations on the container classes. The new language features range from ways to improve template code with fold expressions, constexpr if, and class template deduction over improvements of lambdas to structured bindings and initalizers in if and switch statements.
Why learn what’s new in C++17?
C++ is the language that powers most applications written with Qt. To make the most out of the language, developers need to know its capabilities and pitfalls, and keep up with the incremental changes made in new releases. In this way they will learn to write easier, faster, cleaner and safer code.
Target Audience: C++ developers who want to know more about the new features introduced in C++17. Prerequisite: Knowing the basics of C++11 is a requirement, though more advanced topics will be explained as needed.
Marc is a senior software engineer with KDAB and author of the “Effective Qt” series of articles. He originated KDAB’s “In-depth Multithreading With Qt”, C++11 and C++17 courses, and runs “-Wmarc”, a blog about Qt, C++ and Boost. The second-most prolific contributor to QtBase and former maintainer of the QtWidgets module, he has actively used the framework for more than a decade, first as a KDE contributor, and then on the job. His most recent contribution to Qt is QStringView, a revolutionary abstraction of string data from containers. Marc is a sought-after speaker at conferences on Qt and C++ topics and holds an MSc in Theoretical Physics.
Profiling and Debugging for Linux, trainer: Milian Wolff
This training gives an introduction to various tools, which help developers and testers in finding bugs and performance issues. This variant of the training focuses on Linux.The tools presented cover a wide range of problems, from general purpose debugging and CPU profiling to Qt specific high-level analyzers. Often, it is relatively simple to run a tool, but interpreting the results, or even just using some of the more advanced tools, requires deep technical knowledge.
The following tools will be covered:
- General purpose debugger: GDB
- Record and replay, reverse debugging: RR
- Memory error detectors: AddressSanitizer
- Thread error detectors: ThreadSanitizer
- Various Qt built-in features
- GammaRay to investigate internals of Qt Applications
Static Code Analysis
- CPU: Linux perf and Hotspot
- heap memory: heaptrack
Target audience: Developers who want to find and fix problems. Prerequisites: Knowing the basics of C++ and Qt.