KDAB Training at Qt World Summit 2017 Berlin, Oct 10th
This year KDAB will once again offer a pre-conference training day at Qt World Summit, which runs from 10-12 October.
You can choose between 12 top quality one day trainings and get an in-depth introduction to one of KDAB’s wide range of topics:
[accordion autoclose=”true” tag=”h6″ clicktoclose=”true” class=”acc”] [accordion-item id=”item-2″ title=”Introduction to Qt 3D”]
Target Audience: Developers or Managers wishing to get an idea of what Qt 3D is about and learn how to make some attractive applications with 3D content in the process. 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:
- How to construct a basic Qt 3D application
- About Transform hierarchies and Entities and Components or make a scene graph
- How to display 3D graphical content using geometry, materials, textures
- How Qt 3D maps onto the graphics pipeline
- How to extend Qt 3D to use your own custom geometry
- How to write custom materials and shaders
- How to completely control the Qt 3D renderer dynamically at runtime using the Frame Graph
- How to integrate Qt 3D with Qt Quick to provide a 2D user interface
- How to handle advanced input with Qt 3D
- Future plans for Qt 3D and how to extend it yourself
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.[/accordion-item] [accordion-item id=”item-3″ title=”Introduction to Debugging and Profiling for Qt Development on Linux”]
Target audience: Developers who want to find and fix problems 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:
- General purpose debuggers: GDB
- Memory error detectors: AddressSanitizer
- Various Qt built-in features
- QML debugger
- GammaRay to investigate internals of Qt Applications
- CPU: Linux perf
- Heap memory: heaptrack
- QML profiler
- Static code analysis: clazy
- 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.[/accordion-item] [accordion-item id=”item-4″ title=”Introduction to Qt/QML”]
Target Audience: Developers and managers interested in learning the anatomy 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++.
- 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.[/accordion-item] [accordion-item id=”item-5″ title=”Introduction to Testing Qt GUI Applications with Squish”]Target Audience: Testers, Developers and Managers interested in how to automate testing of Qt applications 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.[/accordion-item] [accordion-item id=”item-6″ title=”Introduction to Modern OpenGL”] Target Audience: Developers interested in learning the basics of OpenGL. 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. [/accordion-item] [accordion-item id=”item-7″ title=”Introduction to Multithreading with Qt”]Target Audience: Qt Developers interested in multithreaded development. 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. [/accordion-item] [accordion-item id=”item-8″ title=”Introduction to Model/View Programming with Qt”]Target Audience: Qt developers interested in model/view either from QML or from Qt Widgets. 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:
- The API to implement for use in a 1-dimensional list, a 2-dimensional table and a tree view
- What model indexes are all about
- How to successfully implement a proxy model
- How to debug your models
- How to implement models in C++ that are displayed in Qt Quick
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. [/accordion-item] [accordion-item id=”item-9″ title=”Introduction to Qt for Mobile Platforms – Android/iOS”]Target Audience: Anyone interested in the process of developing with Qt for mobile platforms 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:
- Installing and setting up Qt for Android
- Installing and setting up Qt for iOS
- Use case: Targeting desktop and mobile devices using Qt
- Device independent development – how do you cope with devices of vastly different resolutions and screen density
- Platform integration – how to access native services and toolkits, the easy way
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.[/accordion-item] [accordion-item id=”item-10″ title=”Introduction to CMake”]Target Audience: C and C++ Developers 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.[/accordion-item] [accordion-item id=”item-11″ title=”Advanced QML”]Target audience: Experienced QML developers targeting embedded and/or mobile platforms. 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.
- Using OpenGL in custom QML elements
- Analyzing and profiling the Qt Quick scene graph
- Understanding and removing bottlenecks that affect a QML UI
- Best practices for achieving optimal performances, even on constrained hardware resources
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.[/accordion-item] [accordion-item id=”item-12″ title=”Advanced Modern OpenGL”]Target audience: Developers wanting to understand realistic advanced visuals and improve pipeline and performance. 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.[/accordion-item] [accordion-item id=”item-13″ title=”What’s new in C++14 and C++17?”]Target Audience: C++ developers who want to know more about the new features introduced in C++14 and 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 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 initializers 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[/accordion-item] [/accordion]
We’ll be running at least 10 of these, so let us know your top preference early.
Check it out, choose your training and Sign up here.