KDAB Training at Qt World Summit Berlin 5th December 2018
KDAB offered eight superb Training Classes in Berlin, you can see the list below, which includes one run by our long-term collaborator, froglogic. All the rest were delivered by KDAB engineers. There were five classes in our Introductory group, and three in the Advanced. Read the descriptions carefully to see which one you’d have liked to attend. An Introductory class can be just what you need for a refresher, even if you’re an experienced programmer, as our trainers are always up-to-date with the latest tips. Introductory Effective 3D in Qt Introduction to CMake Introduction to Qt/QML Multithreading in Qt Qt GUI Testing with Squish Advanced Modern C++ – What’s New in C++17? Profiling and Debugging for Linux QML Applications Architecture
Effective 3D in Qt
with James Turner
Target Audience: Qt developers wishing to integrate 3d technology in their application. Prerequisites: The audience is expected to have familiarity with basic QtQuick and OpenGL concepts, but no in-depth knowledge of them is required.
Starting with the utility and enabler classes (for OpenGL, Vulkan and the upcoming Metal support), we will look at low level support for using OpenGL with QOpenGLWindow for rendering and event handling. We will also look at the support in the Widgets module. Later we will show the technologies available in Qt that allow deep integration of Qt Quick 2 scenes with custom drawn OpenGL content. We will discuss the possibility of simply providing a Qt Quick overlay for an OpenGL scene. The discussion will then proceed to the creation of custom Qt Quick Items drawn using raw OpenGL commands, which can then be used from QML. We will also illustrate how to manually drive Qt Quick’s own rendering if we need to be in complete control of how and when the rendering happens. Finally, we will look at Qt 3D and how to use its scene graphs and frame graphs to create high performance 3d rendering without requiring the specialist knowledge required when accessing OpenGL directly. Along the way we will introduce the Qt 3D renderer and input systems and how they are built on top of a flexible, highly threaded, Entity Component System (ECS) architecture that scales very well and is ripe for future additions. You will learn how to:
- create windows for 3d rendering
- add a Qt Quick based UI to an OpenGL application
- create custom high performance Qt Quick Items using OpenGL
- integrate your own OpenGL renderer with the Qt Quick Renderer
- construct a basic Qt 3D application
- make a scene graph, display 3D graphical content using geometry, materials, textures
- get Qt 3D maps onto the graphics pipeline
- extend Qt 3D to use your own custom geometry
- write custom materials and shaders
- completely control the Qt 3D renderer dynamically at runtime using the Frame Graph
Senior Software Engineer and team lead at KDAB, James has been developing with Qt since 2002. He contributes to the current maintenance of Mac platform support as well as the development of OpenGL and 3D support in Qt. James has a background in user-interface, graphics and simulation development as well as a long history of development on OS-X and prior versions of Mac OS. He is a lead developer on FlightGear, the open-source flight simulator, and holds a BSc in Computer Science.
Introduction to CMake
with Kevin Funk
Target Audience: C and C++ Developers who are interested in how to build their code. Prerequisite: Experience with build systems. “The best thing a build system can do is not get in the way”.
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 alter- native 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.
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
with Jan Marker
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.
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.
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
with Kevin Krammer
Target Audience: Qt Developers interested in multithreaded programming. Prerequisite: Knowledge and experience programming with Qt and C++. A basic understanding of multithreaded programming is an advantage but not required.
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 how to write safe and efficient multithreaded code with Qt. Topics include:
- Basic multithreading concepts (threads, processes, data races, reentrency, shared data)
- Synchronization primitives (mutexes, semaphores, condition variables)
- Special concerns for Qt applications (cross-thread signals/slots, QObject thread affinity, the GUI thread)
- Low-level multithreading with Qt (QThread, QThreadPool, QMutex, etc)
- High-level multithreading with Qt (QtConcurrent)
- Threading with Qt Model/View
- A brief summary of atomic operations
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.
Senior Software Engineer and team lead at KDAB, Kevin has actively developed with Qt and contributed consistently to KDE since 2000. He is a founding member of the QtCentre website and has mentored at Google’s Summer of Code program for 10 years. One of KDAB’s most experienced trainers, Kevin keeps our training material up-to-date and has trained engineers from Blackberry, Lockheed Martin, Siemens and Safegate and many others. Kevin holds a BSc in Software and Communications Engineering.
Qt GUI Testing with Squish
with Tomasz Pawlowski
Prerequisites: The course is for developers and testers already familiar with the basic concepts of Qt.
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.
- 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
Software engineer at froglogic, Tomasz started the adventure with Squish and GUI Testing in 2011, designing and implementing automated tests for a Flight Planning solution at Lufthansa Systems. In 2014 he joined froglogic and is conducting Squish trainings and consulting for many companies in Europe, India and the USA. Additionally, Tomasz is implementing Squish integrations. Tomasz has a degree in computer science from Nicolaus Copernicus University in Poland.
Modern C++ – What’s New in C++17?
with Giuseppe D’Angelo
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.
Starting with C++11 released in 2011, the C++ language and standard library have steadily evolved. At the end of 2017 the new C++17 standard was released, adding a sizable amount of useful new features. All major compilers already support most (if not all) of its 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 done in new releases. Doing so rewards them with ways to write easier, faster, cleaner and safer code
Senior Software Engineer at KDAB, Giuseppe is a long-time contributor to Qt, having used Qt and C++ since 2000, and is an Approver in the Qt Project. 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.
Profiling and Debugging for Linux
with Milian Wolff
Target audience: Developers who want to find and fix problems, Prerequisite: Knowing the basics of C++ and Qt,
This training introduces 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
- CPU: Linux perf and hotspot
- Heap memory: heaptrack
Senior Software Engineer at KDAB, Milian leads the R&D in tooling and profiling in which he has a special interest. Milian created Massif-Visualizer and heaptrack, both of which are now used regularly to improve the performance of C++ and Qt applications. When not applying his knowledge to improving code-base performance for KDAB’s customers, Milian maintains QtWebChannel for the Qt Project and is co-maintainer of the KDevelop IDE. In 2015, Milian won KDE’s Akademy Award for his work on Clang integration. He has a Masters Degree in Physics.
QML Applications Architecture
with Tobias Koenig
Target audience: QML developers who want to learn about creating large-scale yet maintainable applications. Prerequisite: Being comfortable with the basics of QML, as well as some familiarity with developing with C++ and Qt (QObject, signals & slots, properties, etc).
QML is a great language for expressing user interfaces in a declarative, easy to understand way. It can however be difficult to scale up from small demo applications to fully featured, complex systems without paying too high a price in complexity, performance and maintainability. In this course, we explore different techniques to deal with these issues to enable you to scale up your applications while steering clear from the common pitfalls. Topics include:
- Custom QML items
- C++ integration
- Declarative coding
- Multi-page application architectures
- Code organization
Senior Software Engineer at KDAB, Tobias has actively developed with Qt since 2001 and has been an active KDE contributor during this time. His contributions have been mainly to the KDE PIM project and the KDE libraries, but also to other open source projects.
There’s still seats left for the One-Day Training at Qt World Summit in Berlin! Sign up…