Continuing the tradition of great Qt World Summit trainings, KDAB will be hosting the training day for all levels of Qt developers from beginner to seasoned expert.
The trainings are divided into introductory and advanced level trainings.
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++.
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.
Prerequisite: Existing Qt knowledge. Basic understanding of multithreaded programming is also an advantage.
With more and more cores in computers, multithreaded programming is becoming increasingly important for developers.
Qt offers several mechanisms for multithreading, however, it is up to you to decide which to use when so that you steer clear of common pitfalls. This course offers guidance on how to choose.
Why learn about Multithreading with Qt?
This training will introduce you to multithreading concepts in general, tell you about the different mechanism in Qt, and discuss best practices and common pitfalls.
Prerequisite: Existing Qt knowledge. A key ingredient in successful software development is the separation of presentation and business logic. Everyone knows that. A larger part of most applications is a list of things, and for those, Qt offers such separation using a model/view framework.
This presentation will introduce this framework and tell you how to develop models independent of whether they are to be displayed in a C++/Qt application or in a Qt Quick application.
The training dives into subjects such as:
Why learn Model/View Programming?
Model/View Programming teaches efficient displaying and manipulation of data sets of unknown sizes and independent of data source. It allows applications to work with hundreds of thousands of records, from in-memory data, databases or servers.
Prerequisite: Basic Qt knowledge is beneficial. This presentation will introduce the tools and processes needed to develop with Qt for mobile devices, including Android and iOS.
You will learn about:
Why learn Qt for Mobile Platforms?
Qt provides the unique opportunity to leverage toolkits and team experience across all major desktop and mobile platforms. Learn what makes Qt ideal for building common applications on mobile devices.
Prerequisite: A basic understanding of QML would be useful. No prior OpenGL or 3D experience is required.
Qt 5.7 introduced the powerful new Qt 3D module that can be used to integrate 3D content into your Qt applications using C++ or QML. In fact, Qt 3D provides an extensible framework for soft realtime simulations, of which rendering is just one aspect. This 1 day training will introduce you to Qt 3D's features and APIs, show what you can achieve with them, and how Qt 3D can be extended by the user and by the Qt 3D authors in the future.
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:
Why learn Qt 3D?
Integrating 3D content in applications is becoming a clear trend in many fields and is likely to become even more important in the future with the growth of Virtual Reality and Augmented Reality. Qt has always allowed you to integrate with OpenGL fairly easily, but managing the rendering code itself was still a very challenging task, often limited to a few specialized team members. With Qt 3D, you can bypass that challenge as the heavy lifting has already been done.
Prerequisite: A basic level of linear algebra will be assumed for this course (multiplying a matrix and a vector). Mathematics will be kept to a bare minimum so as not to get in the way of eye candy!
OpenGL is a central part of QtQuick2 in Qt 5 and plays a key role in displaying the main content of many widget-based applications.
OpenGL has been around for many years and in recent times has evolved to shed much of its legacy baggage and better expose the underlying hardware. Modern OpenGL allows us to take full advantage of the enormous power and parallel processing power of today’s GPUs. Maximizing performance of OpenGL rendering requires us to understand how GPUs work and how to efficiently feed them with data.
Qt provides a number of classes to make life easier when working with modern OpenGL. This training will show you how to do the basic tasks associated with OpenGL rendering and will go on to show how to use Qt and OpenGL to achieve several rendering effects and algorithms. You will also learn how to write custom QtQuick2 items using the OpenGL and scene graph APIs.
Why learn Modern OpenGL?
OpenGL is the industry standard for high performance graphics and computation on desktop, mobile and embedded platforms. Whether the requirement is visualizing large data sets, creating engaging user interfaces or breathtaking real-time visuals, getting the topics covered in this course is essential.
Prerequisite: Knowing the basics of C++, Qt and QML 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:
Why learn about Debugging and Profiling?
The time spent writing code is often dwarfed by the time required to find bugs and improve performance. This training makes your development workflow more efficient. You will learn what tool to use in which situation, how to set it up and run it on an application as well as how to analyze and interpret the results.
Prerequisite: Basic scripting skills and knowing the basics of Qt are a benefit for this training. Bring your laptop and request a free evaluation license and download in advance through http://www.froglogic.com/squish/evaluate.php.
While unit testing is established to test components, integration and system tests verify that the overall system works as expected. Squish is the tool for automating these blackbox tests in the world of Qt.
The presenter will introduce you to the automated functional testing of user interfaces based on Qt. Besides getting to know the record and playback GUI testing tool Squish, additional topics range from best practices for test design over test refactoring to Behaviour Driven Testing.
This training includes theoretical modules and live demonstrations, but you are invited to join working on practical exercises - bring your laptop to participate.
Why learn about Squish GUI Tester?
Manual testing of user interfaces in applications is often a very complex and error-prone activity. Squish is a proven GUI test automation tool for functional GUI regression tests. Companies in all types of industries, including KDAB, use Squish to reduce the time spent on GUI testing software releases while increasing the quality of their applications.
Prerequisite: Experience with build systems
The best thing a build system can do is not get into 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.
CMake even has strong support for building Qt applications, and it's 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, build-time configurable feature switches and custom build steps.
User Experience Design for Embedded Devices The proliferation of tablets and smartphones has raised customers’ expectations of anticipated interaction with any device. If any system with a touchscreen is not as responsive a tablet, users are immediately disappointed.
Every year, the bar is set higher and it is important to recognize that compared to desktop systems, users of these new touch-enabled devices have different goals and expectations.
This full-day session for software developers will cover valuable User Experience (UX) concepts and techniques to consider before engaging in core development of an embedded systems application.
We will present various scenarios and UX best practices, discuss User Interface (UI) prototyping and testing strategies, examine case studies and work through a design problem.
Prerequisite: A functional knowledge of QML is needed. Developers with more than one year of Qt/QML experience will also benefit from this course which is regularly updated.
This course is designed to take programmers who already know QML to a deeper level of functional understanding.
Why learn Advanced QML?
This course introduces cutting edge QML skills and know-how to boost your productivity at work. It provides understanding of what the QML engine does, showing how advanced standard features are implemented and teaching how to implement similar ones yourself.
Prerequisite: Developers already working with OpenGL, comfortable with the basics of specifying geometry, writing basic shaders and working with image data.
This training explores the implementation of many different rendering techniques to achieve cutting-edge visuals in OpenGL applications.
It also 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 Advanced OpenGL?
In this course, we introduce some of the most widely used and generally applicable rendering techniques, as well as explaining the costs of different graphic operations to get the best from available hardware resources. You will learn how to effectively increase your hardware performance with OpenGL.
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 this year, the new C++17 standard, already supported by major compilers, is going to be released, adding a sizable amount of useful new features.
In this training, the most useful of the new features introduced in C++17 and its predecessor, C++14, will be presented. In cases for which these features depend on features introduced in C++11, 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 and std::string_view. 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++14 and 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