Prominent C++ expert
Herb Sutter is the chair of the ISO C++ committee and a native languages architect at Microsoft. His current work is focused on making C++ more powerful while also making C++ code simpler and cleaner, with the goal of modernizing the language for the 2020s and beyond.
Entrepreneur & Trendwatcher
Igor is an energetic professional communicator with 1,000+ live on stage performances, award-winning marketing strategist for brands Amazon, L’Oréal, Nike and Unilever, new breed trendwatcher, serial entrepreneur with multiple exits, and an angel investor.
CEO, Development center chief, Panasonic ITS
Mr. Tanabe is CEO for Panasonic ITS and heads the Development center which has SW, HW and Mechanical section. He has 20 year's experience in large-scale software development in Automotive system globally (EU, US, JP).
Programmer, storyteller and illustrator
Linda is the author and illustrator of Hello Ruby, a children’s picture book about the whimsical world of computers, as well as the founder of Rails Girls, a global movement to teach young women programming in over 260 cities.
Physicist at University of Melbourne
Dr. Goldfarb is a physicist from the University of Melbourne working on the ATLAS Experiment on the Large Hadron Collider at CERN. He received his Ph.D. in physics from the University of Michigan in 1991, and has been performing particle physics research at CERN ever since.
CTO, The Qt Company
Lars Knoll is The Qt Company CTO and Qt Project Chief Maintainer. He has been working on Qt for more than 13 years starting as a software engineer to later leading the global Qt engineering team in Nokia before the Digia acquisition in October 2012.
Check out some extracts from other presentations
For a long time it has been possible to add some level of animation to your Qt applications by way of QPropertyAnimation, and then more recently with the Qt Quick Animation framework. You could even use these along with the object types within Qt 3D to animate your virtual worlds. However, we can go further both in terms of features and performance.
Qt has traditionally targeted developers. However, we see increasing demand for it to adapt and to also support the needs of content creators and artists. Animation is a prime example of this. It is no longer feasible to provide only support for creating animations programmatically. Artists want to be able to use their own familiar tools such as Blender or Maya to author animations and then be able to export them for consumption by applications. This meant adding support for key frame animations – something developers have also been asking for over the years.
Qt 3D now offers the ability to consume key frame animations exported from external tools or to create your own key frame animations in code. In addition Qt 3D offers a collection of types to make it convenient to work with such animation data. In this talk we will take a deep dive into the new animation subsystem of Qt 3D.
Speaker – Dr Sean Harmer, KDAB
At the heart of Qt is the QObject and the technologies that drive this. As Qt developers we love to use signals and slots, the events, the introspection and all those other features. But how do those actually work?
Surprisingly few Qt developers truly understand how the QObject systems work. And by not understanding, they fail to grasp the full potential of what this can help you with.
In this talk, we will dive very deep into the belly of the beast and discuss how it actually works. You will see what moc does, how it’s related to QObject and why it’s necessary. You will learn all there is to learn about what QObject does for your objects. We will also look at the Qt event loop and see how this is related to QObject and the Qt signals. This is necessary to understand what happens to your Qt signals.
Speaker – Bo Thorsen, Viking Software
Qt Lite is an initiative driven by The Qt Company striving for smaller and leaner Qt builds. It utilizes the new configuration system introduced with Qt 5.8 to create custom builds stripped of features or classes that aren’t needed for a given application. Focus is mostly on Embedded Linux with the goal of making Qt a feasible option on smaller systems.
Qt Lite consists of two parts: The first part are changes to the Qt source code and configuration system itself to allow for compiling certain aspects out. This is part of the Open Source code base. The second part is a UI tool to manage build configurations and is part of “Qt for Device Creation”.
This presentation will look at the current state of affairs for both sides and provide guidance on how to work with Qt Lite on your own.
Speaker – Frank Meerkötter, basysKom
This session highlights Qt applications designed for multiple platforms developed by V-Play. We will share our experience & best practices learned from more than 40 published apps in the mobile app stores, embedded devices and Desktop PC. The Qt showcases include:
• Business cross-platform applications used by Fortune 500 companies like T-Mobile and Novartis on iOS, Android and Windows Phone with more than a million downloads, powered by Qt.
• A remake of the popular UNO card game with Qt including multiplayer support to play against other players world-wide. We will highlight how this game was developed in less than a month, and how some of the retention features from the gaming world can be used in business apps.
This talk shows the diversity of applications you can make with Qt, and gives you tips how to create your own cross-platform applications more efficiently. You will learn:
• How to improve the development lifecycle with testing and deployment optimizations.
• How to speed up your time-to-market.
• How Qt compares to other application frameworks like React.
• Which 3rd party tools helped us to save the most time in the software life-cycle.
Speaker – Alex Leutgöb, V-Play Engine
The build system is one of the most important aspects of a streamlined software development pipeline. A build tool is something that developers use throughout the day, every day, and should be lightning fast, easy to use, and produce instantaneous and correct incremental builds. Build systems that are slow, hard to maintain, or underspecify dependencies (leading to broken or malfunctioning builds) significantly impact your team’s workflow and waste countless hours of time.
Qbs aims to be the perfect high level cross platform build system — and intended replacement for qmake within Qt. It started as a research project at Nokia in 2010 and has been ongoing since, with the initial Qt port planned for completion this year in 2017. Qbs aims to support any toolkit, any language, and any OS, with excellent support for cross compilation, IDE integration, embedded device deployment & packaging, speed, flexibility, expressiveness, and ease of use.
Speaker – Jake Petroules, The Qt Company
QtIVI has been part of Qt Automotive Suite since its initial release. It is designed to facilitate the creation of Qt based interfaces for integration vehicle functions such as climate control, media services, etc.
Creating such interfaces involves deriving from QObject, exposing properties, mapping values and calls to the native supporting APIs. Many concepts require create custom models and handling the various updates. Also, it can be useful to build versions of the API which provide simulated version of the APIs so work can be performed with a real vehicle, or to handle specific scenarios. Finally, testing and profiling tools for the native APIs are usually cumbersome and do not integrate with Qt nicely.
Qt Automotive Suite introduced a number of pattern to handle these issues, such as a base classes for basic scenarios, usage of switchable plugins for selection real vs simulated backends, tools in Gammaray to access and manipulate properties of objects at run time.
However, this still requires writing many objects and models to integrate with Qt UIs as well as integrating the backend APIs and maintaining the required plugins.
In order to facilitate this process, Qt Automotive Suite introduces code generation. Using QFace, an open source interface generator framework, interfaces are described in an IDL which support constructions familiar to Qt, such are properties, operations, signals, models, etc. QtIVI then uses a specific generators to produce code for the frontend Qt code and for the backends.
The IDL supports defining further concepts such as valid ranges, default values, etc. These are used in the simulator backend to provide debugging. QtIVI can also generate a backend which supports unit testing based on the provided values.
We show how using the code generation can be used fully automate the generation of the frontend code while produced stubbed backend code which can be easily extended. Furthermore, we show how the actual generation, which is based on a template system, can be modified to automate the generation of the backend along with much of the integration code.
Speaker – Mike Krus, KDAB
The home automation industry is growing. The new QtKnx module is home automation software development made easy, and open to all. We show how the KNX standard for home and building control is made available by the QtKnx module. This represents a world of opportunity in terms of developing applications, as stand alone use cases or in partnership with existing technology.
This presentation is a general overview aimed at technical minded and business people alike.
Speaker – Lucie Gerard, The Qt Company
HMI for automotive is getting more important and crucial area as vehicles are acquiring more advanced safety functions. Traditional development process of HMI has many issues, troubles and hassles, and many people just got used to it.
One thing we need to remember is the fact that we have got used to the traditional development process of HIM at the cost of creativity, which is the most important ingredient of powerful HMI. The goal of HMI development is not to create something easy to implement, but to create something attracts users. To achieve this goal, we obviously need more appropriate development process of HMI, and many people are working on it.
In this session, we propose a solution to maximize your creativity while guarantee productivity by combining a powerful toolchain, TRITO Linkage, and the powerful application framework, Qt.
TRITO Linkage is a toolchain which consists of variety of plug-ins for many of Adobe applications such as Illustrator, Photoshop and Animate and standalone tools such as code generator. With TRITO Linkage, designers can easily bring their ideas to the real world, and they can hand the ideas to engineers without any hassle so that engineers can easily implement the application, thanks to the power of Qt framework. In the traditional development process of HMI, designers need to create spreadsheets to communicate with engineers and wait for a long time to see their design running in the real device.
Why do we need spreadsheets to create design in the first place? TRITO Linkage and Qt will get rid of all of those unnecessary work, and let you focus on what you really need to focus on.
Speaker – Hirotaka Suzuki
With Qt5.9, the Qt Location module has received numerous new features, some of which have finally disrupted the internal limitations the module used to have.
Thanks to this, the module can now make use of 3rd party, pluggable map engines for displaying the maps and the user-added content on the maps. The module now also allows tilting and rotating maps. Many other features have been also introduced, still maintaining source and binary compatibility as always.
In this talk you will learn what features are now available in QtLocation 5.9, how to use them, and what new scenarios they enable.
Speaker – Paolo Angelelli, The Qt Company
Over the last few years we have discussed adding a new way in QtQuick to handle events from pointing devices such as touchscreens, mice and graphics tablets. Now it is on track to ship in 5.10.
This is an update and demo of the current status. A PointerHandler is a lightweight C++ object which handles pointing device events on behalf of a parent Item, in order to implement a specific gesture. So far we include implementations of TapHandler (which detects taps, clicks and long-presses, from any device, or from a specific device); DragHandler, which drags its parent Item, or an alternate target; and PinchHandler, which handles two or more touch points to scale, rotate and drag its parent Item or alternate target. Other handlers are coming; and in the future, we intend to have public C++ API for implementing your own.
Speaker – Shawn Rutledge, The Qt Company
With Qt quickly becoming the dominant means of developing In-Vehicle Infotainment Systems, developer teams worldwide face the choices of structuring applications at source and physical levels in ways, providing for comfort of development and debugging, ease of deployment and intellectual property protection. Being at the core of Qt’s own architecture, plugins offer ultimate flexibility in above regards, yet some of the crucial aspects of developing plugin-based architectures are surprisingly lesser known. This talk aims at providing the missing pointers, touching on: – Providing both visual items and styling via plugins – Mixing C++, QML, translations, assets and resources in plugins – Plugin loading, unloading and memory management – Developing custom plugin formats The concepts and scenarios described in the talk will be illustrated by several live demonstrations.
Speakers – Vladimir Moolle & Krzysztof Krzewniak, ICS
Healthcare is held back by lack of access to quality clinical data. Access to quality clinical data is difficult due to lack of interoperability between medical devices. Periodic EMR documentation is not adequate for fueling research, Artificial Intelligence (AI), or Machine Learning (ML). The ASTM F2761 standard describes the Integrated Clinical Environment (ICE), an infrastructure for supporting interoperability between medical devices and user access facilitated through apps.
Building on the ICE architecture, DocBox has created a platform that enables the development and use of clinical apps. These clinical apps support advances in operational and clinical automation, and improvements in patient safety. DocBox has chosen Qt as the application framework to build the bedside touchscreen HMI (Human Machine Interface), and clinical apps built on the platform. We wanted to create an HMI with a modern, intuitive UI. Qt Quick allows us to rapidly build apps made up of re-usable UI components, while taking advantage of gestures unique to a touch screen interface.
This talk will demonstrate how we’ve repurposed the Qt Application Manager from the Automotive Suite.
Speaker – Jereme Givens-Lamothe, DocBoxInc
We are constantly updating this page, so stay tuned for more information about upcoming talks and exceptional speakers.