Qt World Summit Training – Berlin 2019 Course descriptions

10.01.2020 Frances Tait No comments

At Qt World Summit in 2019, KDAB offered five Introductory courses (one was given by our partner, froglogic), and three advanced classes., as follows:

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.

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.

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.

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.

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.

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.

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.

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:

Debugging

• 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

• Compilers
• Clazy

Profiling

• 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.