Lightning Talks

Tuesday, October 7th - 16:30 - 17:30 


Room: A3+A4

Title Presenter
QtRemoteObjects introduction Björn Breitmeryer
Raspberry Pi as invisible hardware Samuel Gaist
Display Map data in QML apps Mike Krus
What is that parameter again? Seconds, milliseconds? Mathias Hasselmann
Plasma - A flexible workspace shell David Edmundson

Room: A5+A6

Title Presenter
Categorized logging in QML Giuseppe D'Angelo
Applying the Presentation Model Design Pattern in Qt Style Juan de Hoyos
2-in-1 Office Suite Dan Leinir Turthra Jensen
How to write a benchmark Kai Koehne
Your work is bad and you should feel bad! - how to deal with idiots Jens Reuterberg

Room: B5+B6

Title Presenter
QtQuick2 Debugging With GammaRay Volker Krause
LXQt – The next generation of the Lightweight Desktop Environment Christoph Wickert
slice and dice your item models with QDatacube Sune Vuorela
Improving the speed of the moc'ing steps Aurelien Regat-Barrel
Qt5 on a microcontroller! Frank Meerkötter

Room: B7+B8

Title Presenter
Introduction to the Declarative State Machine Framework (DSM) Kevin Funk
The GLEAMviz Simulator client: Qt and computational epidemiology Corrado Gioannini
& Paolo Milano
A pure QML/JS approximation of node.js' require() mechanism Sumedha Widydharma
Closing the Gap between Qt/QML & Android/iOS: Secrets of Native Plugin Development Alex Leutgöb
Ableton Styles: CSS in QML Gregor Klinke

Room: B9

Title Presenter
Side-by-side assemblies with Qt Creator - the comfortable way Vladimir Moolle
Qt-powered tools for modeling forest ecosystems Werner Rammer
Qt Champions program Tero Kojo
Heaptrack - A Heap Memory Profiler for Linux Milian Wolff
High-performance graphics using OpenGL streaming in the Embedded Linux and Android emulators Laszlo Agocs

Room: C1

Title Presenter
Brain waves analysis using Neurosky mobile EEG Sebastiano Galazzo
injeqt - dependency injection for Qt applications Rafał Malinowski
The Polar Positioner Tobias Koenig
Salvaging Qt Designer file Kevin Krammer
C++ Conferences Jens Weller

Abstracts

Room: A3+A4

Room: A3+A4
Title: Raspberry Pi as invisible hardware
Presenter: Samuel Gaist

When writing a presentation or a course which subject would need a connectable device that might be too expensive or too big to move, the Raspberry Pi can come handy to become a simulator that will allow to demonstrate the goal of that course. This talk will present the simulator written for the session "Test Driven Development for Invisible Hardware"


Room: A3+A4
Title: Display Map data in QML apps
Presenter: Mike Krus

QML, on mobile device in particular, does not provide an easy of displaying maps. This talk highlights multiple ways of displaying maps as well as over-layed application data. After looking briefly at webkit and the Google Maps JavaScript API, we show how to use OpenSceneGraph & osgEarth. We look at various sources of map tiles, including offline options, and ways of displaying application data overlayed on the map.


Room: A3+A4
Title: QtRemoteObjects introduction
Presenter: Björn Breitmeryer

QtRemoteObjects is a remoting framework for QObjects. Unilke other RPC frameworks it's build with Qt and for Qt specifically. It enables you to access properties of QObjects living inside another process or even to establish signal/slot connections between QObjects on different machines, all without even noticing the difference to local objects.


Room: A3+A4
Title: What is that parameter again? Seconds, milliseconds?
Presenter: Mathias Hasselmann

The above question is a just way too common in your daily routine. Wrong answers to it crashed thousands of programs... well and even Mars probes. All known solutions to the unit problem are cumbersome and bureaucratic. Really all of them? How about those user defined literals C++11 introduced? Can they save the day?

Room: A3+A4
Title: Plasma - A flexible workspace shell
Presenter: David Edmundson

In this presentation I will showcase KDE's Plasma. Plasma as a lego-like workspace shell with interchangeable components allowing it to morph not just into different style desktop shells but also into a completely different use-cases such as an embedded media centre.

This presentation will give an overview of how the various components fit together and how others can use this to create their own shell.

Presenter Bio: David Edmundson has been working in and around KDE for the last 5 years, he is now the maintainer of Plasma, KDE's desktop environment along with other projects. He currently works for Blue Systems located in their office in Barcelona.


Room: A5+A6

Room: A5+A6
Title: Categorized logging in QML
Presenter: Giuseppe D'Angelo

Qt 5.2 introduced a categorized logging framework. The framework allows the developer to have fine-grained control about which debug/warning messages get printed, and to get detailed information (source file, line number) about where the message is created from. Unfortunately, up to Qt 5.4, this framework is C++ only, i.e. it's not exposed to QML. In this lightning talk I will show ways to work around this limitation.

Presenter Bio: Giuseppe D'Angelo holds a BSc in Computer Science. He is a long time contributor to Qt, having used Qt since 2000, and an Approver in the Qt Project. His contributions in Qt range from containers and regular expressions to GUI and OpenGL. A free software passionate, before joining KDAB, he organized conferences on opensource around Italy, especially about Perl.


Room: A5+A6
Title: Applying the Presentation Model Design Pattern in Qt Style
Presenter: Juan de Hoyos

In complex user interfaces is sometimes a good idea to pull the state and behavior of the widgets out of the widgets and create and additional abstraction layer between the widgets and the domain model. This layer collects the domain data needed to display and guarantee consistence with the model underneath, without need of polluting the widgets with complex additional logic. To address this problem, the Presentation Model design pattern was born. However, the price we have to pay is adding more complexity to our application. More concretely, we need a way to keep the model, the view and the domain layer synchronized.

By leveraging from core features of Qt and QML like signals/slots and the high degree of expressiveness of declarative programing, we can apply the Presentation Model with much less pain as we’ll experience in raw C++.

During this talk, an example of using this pattern in a simple application will be discussed.

Presenter Bio: Juan de Hoyos is Lead Engineer at Zühlke Engineering GmbH and develops software with C++ and Qt for more than 10 years.


Room: A5+A6
Title: 2-in-1 Office Suite
Presenter: Dan Leinir Turthra Jensen

2-in-1 devices are fast becoming very popular, and after the success of Krita Gemini, a digital painting application with an adaptable user interface, the team behind it realised there were plenty of reasons to apply that same concept to other applications, and especially the others in the Calligra office suite. In particular the Words and Stage components were deemed ripe for this treatment.

With that realisation was born the desire to create Calligra Gemini, an application encasing word processor and presentation components which would function both as a traditional desktop application with a mouse and keyboard, and transform into a touch friendly application on the go, changing the experience to one suitable for all-touch devices without the inconvenience of having to switch to a different application.

In this, you will get a short introduction to the project, and some of the vital functionality of Qt employed within it to make it work. Presenter Bio: Dan, or Leinir as he is known to most, has been an active part of the KDE community for nearly a decade, through his time at university, which resulted in a Master's degree in Information Technology specialising in Game and Engine Programming and most recently has been employed by KO GmbH to work with the Calligra office suite and various projects based on its technology, including the Documents application created for Jolla's first device, which involved porting Calligra to Qt 5. Outside of employment, he has worked on the Amarok and GamingFreedom.org projects, and outside of KDE is an author of science fiction and not too shabby when it comes to knocking up a bit of food.


Room: A5+A6
Title: How to write a benchmark
Presenter: Kai Koehne

QTestLib and Qt Creator makes it dramatically easy to benchmark for self-contained code. I'll demo how to write a meaningful benchmark in less than 5 minutes, but also briefly mention other profiling techniques.


Room: A5+A6
Title: Your work is bad and you should feel bad! - how to deal with idiots
Presenter: Jens Reuterberg

The problem with an open development structure and the current social media interaction with devs and designers is that it attracts some of the worst people who will, the second they think you're not doing exactly that which THEY want you to do, attack. Often hidden under the guise of "valid criticism". This talk is a quick line in the sand against dev harassment and what we can do to stop it.

Presenter Bio: Illustrator, Designer and Open Source aficionado from Sweden who started work for KDE in January 2014 by creating the Visual Design Group with the goal of tearing down the Ivory Tower of design and making it open to all, focusing on inclusiveness, egalitarianism and cooperation instead of self-isolation, strict hierarchies and competition. Focusing on teaching people who weren't so experienced in design but had the ambition to be so this has created the situation that KDE went from 1-2 designers to 10-40 designers over a a one month period.


Room: B5+B6

Room: B5+B6
Title: QtQuick2 Debugging With GammaRay
Presenter: Volker Krause

Enabled by the remote debugging work in GammaRay presented here last year, GammaRay got a number of tools to aid analyzing QtQuick2 applications during year. These include basics like browsing the item hierarchy and inspection and live editing of their properties, as well as layout visualization. But there are also more advanced tools to assist development of custom items or rendering performance analysis, such as a scene graph browser and access to item shaders and geometry. Another sometimes tricky topic, event processing and focus handling, is also covered by a event flow visualization.

Presenter Bio: Senior Software Engineer at KDAB, Volker has been developing with Qt for more than ten years now. He works in Berlin's KDAB office as a team lead, consultant and trainer. His experience with Qt spans desktop and embedded platforms, with a focus on software architecture and tooling. He has taught many 'Programming with Qt' trainings throughout Europe and is a long-term contributor to the KDE project. In 2010 Volker started the GammaRay project to address the need for QML debugging tools (which did not yet exist at this time), and has lead the project since then.


Room: B5+B6
Title: LXQt – The next generation of the Lightweight Desktop Environment
Presenter: Christoph Wickert

LXQt is the next generation of LXDE, the 'Lightweight X11 Desktop Environment'. The project was launched back in 2006 and ported to Qt in early 2013. In the short time frame after the migration, the LX desktop made huge steps forward: It's still as fast and lightweight as ever, but has become a lot more mature, more powerful and easier to use. With a collection of slick and yet powerful apps, it is the leading alternative to KDE in scenarios, where a feature-complete but lightweight desktop is needed, e.g. terminal servers or your next embedded device. And thanks to Qt, development has just become easier, quicker, and more fun.

In this talk Christoph Wickert will showcase the latest LXQt release, tell you why you should use it and how you can contribute to the project.

Presenter Bio: Christoph Wickert is a long-time contributor to various Free and Open Source projects such as the Fedora Project, the Kolab groupware solution, the 'One Laptop per Child' initiative and the Xfce and LXDE desktops. He is currently a member of the Fedora Advisory Board and the speaker of the LXDE Foundation.


Room: B5+B6
Title: slice and dice your item models with QDatacube
Presenter: Sune Vuorela

QDatacube gives pivot tables to your item model. It is a new nice tool to let you slice and dice your item models in cool and interesting ways. QDatacube for example lets you find and select your contacts grouped by employer, by country of origin, by first name and whatever data you have in your model. QDatacube was recently published as a lgpl-library on gitorious.

Presenter Bio: Sune Vuorela makes software for the container shipping industry using various solid technologies, including Java, Qt and KDE Frameworks, as well as contributes to opensource projects like Qt, KDE and Debian.


Room: B5+B6
Title: Improving the speed of the moc'ing steps
Presenter: Aurelien Regat-Barrel

Visual C++ projects generated by qmake (nmake and vcxproj) suffer from a severe limitation: moc and uic are called in a serial fashion. What a frustrating thing to have to wait several minutes for your moc'ing and uic'ing steps when 7 cores in 8 are doing nothing!

During this talk, I'll first present a tool to easily parallelize such calls to moc and uic on existing VC++ projects without having neither to change nor to regenerate them. Then we will see how to go further by patching qmake to merge the generated cpp files in a single compilation unit (unity build). The speed gain can be significant, and is not restricted to the Windows platform.

This way I hope to trigger a debate on how we can improve our project build times and hence become more productive with Qt!


Room: B5+B6
Title: Qt5 on a microcontroller!
Presenter: Frank Meerkötter

Recently we were requested to port an application to Qt. The target platform was a Cortex-M3 based microcontroller. This quickly turned out to be infeasible as the design was solely relying on the internal RAM of the M3 which amounts to 128KB...

Still this got us curious - given some more RAM - can Qt be used on such a small system? It turns out the answer is yes. By utilizing uCLinux it is relatively easy to use some parts of Qt. This talk gives a quick technical overview of such systems. We will highlight some of the hurdles we encountered and give the pros/cons for such a design.

Presenter Bio: Frank is a development lead at basysKom GmbH where he is providing expertise on system & software architecture in the Qt/C++ area. He has over ten years of experience working with a wide range of Embedded Linux based systems often in combination with Qt.

Frank is enthusiastic about building systems with FOSS tools and components.


Room: B7+B8

Room: B7+B8
Title: Introduction to the Declarative State Machine Framework (DSM)
Presenter: Kevin Funk

The Declarative State Machine Framework provides classes for creating and executing state graphs in QML. In this talk I'll give a short introduction to the framework which will arrive in Qt 5.4

Presenter Bio: I'm Kevin Funk, a programmer and FOSS Evangelist and a KDE enthusiast since my very first encounter. I'm currently finalizing my master's thesis about a graphical tool for designing state charts at KDAB.


Room: B7+B8
Title: The GLEAMviz Simulator client: Qt and computational epidemiology.
Presenter: Corrado Gioannini & Paolo Milano

We present a Qt desktop application developed within the scope of the GLEAMviz research project (http://www.gleamviz.org/), involving scientists and developers from different institutions and aimed ad providing a tool for simulating global scale epidemic spreading scenarios.

The Qt application consists in a software client allowing epidemiologist to model disease scenarios with a graphical interface, submit them to a computational server for execution, and then retrieve the output data and analyze and display the temporal evolution of the epidemic by means of different visualization options.


Room: B7+B8
Title: A pure QML/JS approximation of node.js' require() mechanism
Presenter: Sumedha Widydharma

After a brief stint in the world of node.js I had become quite attached to the use of node modules and require() to structure my JavaScript code.

This, coupled with a constant curiosity how viable pure QML/JS (without a C++ foundation) is as a development tool, lead me to spend an afternoon hacking together an implementation of the basic functionality for QML in JavaScript.

This talk will present a short overview of what was implemented, what you can and can't do with it and where you can find it.

It's neither feature complete nor safe to use, but it was an interesting experiment while waiting for ECMAScript 6 module support.

Presenter Bio: Sumedha is a system integrator and developer at basysKom GmbH where he is lucky enough to be able to work with, and sometimes on Qt. After his first contact with GNU/Linux in university he could not really let go and, after a short stint elsewhere, seeked out a Linux-friendly employer and found basysKom. For the last three and a half years he has been working as a system integrator and developer on lots of projects involving embedded Linux, Qt and much more.


Room: B7+B8
Title: Closing the Gap between Qt/QML & Android/iOS: Secrets of Native Plugin Development
Presenter: Alex Leutgöb

With the release of Qt 5 iOS & Android developers got a serious alternative for mobile cross-platform development. When it comes to the integration of platform-specific frameworks & services there is however still an unclosed gap between the “Create Once. Deploy Everywhere.” vision & reality:

In this talk I shortly introduce some of the initial challenges & the key concepts when connecting Qt apps with native functionality.

I cover how to implement native method calls and how to add callbacks from Objective-C & Java / JNI to Qt Quick. I also show how to add custom native views like ad banners on top of Qt Quick interfaces and cover the native app life-cycles on iOS & Android and how to attach your own functionality to them.

This talk also shows how we solved some of the difficulties at development of V-Play Qt 5 Plugins, the leading native plugin extensions of Qt 5 for iOS & Android.

Presenter Bio: Alex has been developing mobile apps since the very first iPhone was introduced. His passion for apps & games lead to starting his own business in 2008, offering solutions for clients including Fortune 100 companies, as well as smaller businesses and independent developers. With a profound knowledge for the mobile platforms iOS, Android, BlackBerry & Windows Phone his apps were downloaded more than a million times in app stores.

After facing the challenges of multi-platform development he soon got into Qt. As a result he co-founded V-Play Game Engine in 2012, a Qt-based game engine on top of QML. Besides working on V-Play Alex frequently speaks at developer meet-ups and other events.


Room: B7+B8
Title: Ableton Styles: CSS in QML
Presenter: Gregor Klinke

Styling QML applications can be tricky because there's no clear separation of appearance and behaviour. This talk will show a way to use stylesheets in QML Applications using a QML plugin to load CSS stylesheets and apply selector rules to the component hierarchy. The implementation supports dynamic reloading of stylesheets and works well with CSS preprocessors like SASS, enabling a streamlined workflow between developers and designers.

Presenter Bio: Gregor Klinke is a software developer at Ableton, where he's working on music software. He's using Qt and Qt Quick only since recently, but is intrigued by its possibilities.


Room: B9

Room: B9
Title: Side-by-side assemblies with Qt Creator -- the comfortable way
(building xcopyable .NET-talking Qt applications)
Presenter: Vladimir Moolle

As many probably know, despite relying on native code, Qt can talk to Windows .NET assemblies perfectly well. WIth a caveat: the interop happens via COM, and OS-global registration of types is traditionally required.

Side-by-side assemblies (or Registration-free COM) is a technology allowing to avoid this registration step on Vista+ OSes, making it possible to:

  • rely on type information embedded in .exe and .dll files themselves (hence no registration and Windows registry pollution)
  • freely copy native and managed binaries across directories and machines (hybrid .NET/C++ applications can be distributed in .zip files - perfect for “preview” builds, for example, as no installation is needed)

The only downside of side-by-side assemblies is that the technology is somewhat scarcely documented (which is especially unfortunate given one can run into forms of the notorious “dll hell” on even a slightest mistake); additionally, integrating side-by-side assemblies into a qmake project has some specifics of its own.

This talk will present:

  • a detailed walk through the steps required to properly incorporate side-by-side assemblies into a qmake project (including adding reliable incremental build support)
  • a template Qt/C# project demonstrating above techniques
  • a sample application

Presenter Bio: Vladimir Moolle is a Qt/QML developer at Integrated Computer Solutions, and a co-author of the “Effective QML“ training course


Room: B9
Title: Qt-powered tools for modeling forest ecosystems Presenter: Werner Rammer

Today, simulation modeling is increasingly recognized as one of the main methodological pillars in ecological sciences. One example are forest models, that typically simulate the development of trees (within forests) over time, driven by environmental factors such as climate and soil conditions. Numerous models have been proposed in the scientific literature, targeting different spatial and temporal scales, and differing in the number and complexity of the modeled processes. Accordingly, the technical implementation ranges from simple Mathlab functions to complex object oriented software. iLand, the individual-based forest landscape and disturbance model (http://iland.boku.ac.at) is an example of the latter: iLand is written in Qt/C++, released under GPL and is well documented in the scientific literature and in an comprehensive online wiki.
In this talk the basic principles of forest ecosystem modeling are discussed. Particularly, the talk highlights the requirements of scientific software development in this field, and discusses how Qt provides solutions for issues such as multithreading, or application in cluster computer environments. Along a quick glance on the GUI of the model, typical model applications are discussed, ranging from climate change impact assessments to theoretical biological research.

Presenter Bio: Werner Rammer has a solid background in both software engineering and environmental sciences. He combines 20+ years of experience in IT and software development with more than 10 years in science. He works now at the University for Natural Resources and Life Sciences, Vienna, mainly on the development and application of ecosystem models. The scientific record consists of >20 SCI-listed publications (h-index: 11). Werner started to use Qt six years ago – and never looked back. What he likes most is the multi-platform/open-source philosophy, the consistent API, and the raw power of C++. Werner lives with his family in Vienna and enjoys playing guitar and designing T-shirts.


Room: B9
Title: Qt Champions program
Presenter: Tero Kojo

The Qt Champions program is launching and will include a wider audience than previously. This time community actives, wiki gardeners, bug triagers and other community contributors in addition to coders can apply for a nomination in the program. The talk will include a description of the program, all the new titles, instructions on how to apply for a title and how the nomination process will work. The session will also possibly include the first title nominations.

Presenter Bio: Tero works as the online community manager for Digia, Qt. His main focus is making sure the Qt community feels at home and has all the tools and services it needs. Tero has a background in various software engineering positions and tasks ranging from requirements elicitation to teaching. Tero is a firm believer in open software and common sense. In addition to a Licentiate of Technology in Software Engineering, he holds an M.Sc (Tech) in Chemistry. Tero is based in Helsinki, Finland.


Room: B9
Title: Heaptrack - A Heap Memory Profiler for Linux
Presenter: Milian Wolff

Over the last months I created a new tool to profile heap memory on Linux, which I call HeapTrack. It can give you similar information as Valgrind's Massif tool, just quicker. Furthermore, the recorded data allows many more interesting insights that cannot be found with Massif. In this talk I will demo HeapTrack and show you that it is already a very useful addition to a developer's set of performance tools.

Presenter Bio: Milian Wolff works at KDAB as a Software Engineer and contributes to Qt and KDE for quite some years now. Tooling in general is of huge interest to him: For KDAB he contributed to PhantomJS, a headless WebKit based on Qt, which is an incredibly useful tool for any web developer. Furthermore he worked on GammaRay, which is invaluable to any Qt developer. Within the KDE community, he is one of the most active contributors to KDevelop and Kate. He wrote the Massif-Visualizer, played around with a GDB based profiler and also looked into tooling around Linux malloc to investigate memory consumption, performance and fragmentation issues.


Room: B9
Title: High-performance graphics using OpenGL streaming in the Embedded Linux and Android emulators
Presenter: Laszlo Agocs

The first release of the emulator environment in Qt Enterprise Embedded was lacking in many ways when it came to graphics performance. Both widget and Qt Quick applications performed sluggishly and featured rendering glitches. For version 2.0 the graphics architecture got a complete redesign: instead of transferring images between the virtual machine and the emulator application on the host, we switched over to sending the EGL and OpenGL ES command stream instead. By being independent of the framebuffer size, this drastically reduced the amount of data, and, by heavy utilization of multiple rendering threads, resulted in a high performing system capable of running Qt Quick application at a stable 60 FPS. In the talk we will take a quick look at the emulator itself and discuss the GL streaming solution architecture with its benefits and trade-offs.

Presenter Bio: Laszlo is a senior software engineer at Digia in Oslo, Norway. After years of UI framework development on various Nokia mobile platforms and a brief time of developing mobile GPUs at ARM, he is now working full time on Qt. His focus is on graphics, platform adaptation, windowing system integration and input device handling, in particular on embedded devices running Embedded Linux or Android. However, in a true cross-platform Qt spirit, he is not afraid of other systems either, and is often helping out with OpenGL support on Windows too. He is a major contributor to QtGui, QtQuick and the platform plugins. Laszlo holds a Bachelor's degree from the Jyvaskyla University of Applied Sciences and a Master's from the University of Debrecen.


Room: C1

Room: C1
Title: Brain waves analysis using Neurosky mobile EEG
Presenter: Sebastiano Galazzo

Using Neurosky's mobile EEG headset (http://neurosky.com/products-markets/eeg-biosensors/hardware/) is possible to analyze brain waves in order to get informations like attention, meditation, stress levels. More through wave's patterns analisys is possible to activate actions mind controlled. Of course we are not talking about mind / though reading but again brain wave analisys.

Presenter Bio: Microsoft MVP, Nokia Develoepr Champion, winner of sever develop international contests I'm passionate of image processing and artificial intelligence. During the day I develop semantic solution for NLP then mobile application focused on image processing and AI.
https://www.youtube.com/watch?v=uKXPMOwBK60


Room: C1
Title: injeqt - dependency injection for Qt applications
Presenter: Rafał Malinowski

Dependency injection is an implementation of inverse of control and can be used to increase program modularity and extendability. In general it also results in more testable source code. There is a lot of dependency injection frameworks for bytecode based languages like Java and C#, for instance Guice and Spring. C++ lacks reflection facilities that make dependency injection so powerfull in these languages.

Injeqt is an attempt to build a powerful and reliable dependency injection framework on Qt's reflection based on MOC (meta-object compiler). It is already being used in master version of Kadu instant messenger application.

I will present current state of injeqt library, its possibilities and limits. I'll also talk about its internals and how it is pushing meta object system to its limits.

Presenter Bio: My name is Rafał Malinowski. I have worked with Qt Open Source for more than 10 years, starting with 3.x versions and gradually upgrading as time allows. Kadu is and instant messenger application that started my interest in Qt and I'm continuing to work on that program in my spare time. My main interest is to gradually improve code quality as my knowledge is expanding and I learn new way of doing things (I also learn how old ways fails in some aspects).

Currently I'm working on injeqt dependency injection library and on gradually moving Kadu to use it as its backbone.


Room: C1
Title: The Polar Positioner
Presenter: Tobias Koenig

QtQuick provides a couple of convenience positioner elements to layout arbitrary QQuickItems in a row, a column, a grid or a flow. One thing you might have missed so far is a positioner to align items along a circle (e.g. to create a tachometer or a gauge). This lightening talk presents how to implement such a custom positioner.

Presenter Bio: Tobias has actively developed with Qt since 2001 and has been an active KDE contributor for the same time. His contributions have been mainly to the KDE PIM project and the KDE libraries, but also, to some smaller extent, to other open source projects. He holds an MSc in Computer Science.


Room: C1
Title: Salvaging Qr Designer files
Presenter: Kevin Krammer

Established Qt based products have dozends, hundrets or even more UI components that have been composed using the Qt Designer visual editor.

Its output are XML documents that, in a traditional QtWidget based program, are converted to C++ code by UIC, Qt User Interface Compiler.

When using QML, with UI component sets such as DeclarativeWidgets or QtQuick.Controls, these files can no longer be used directly.

This lightning talk will show a proof-of-concept work that, similar to UIC, takes Designer's XML files and generates code, but QML instead of C++.

Presenter Bio: Kevin has been developing with Qt since it early versions, both as a professional software engineer as well as a contributor to Qt based Free and Open Source Software communities.

He's currently a senior software engineer and Qt trainer at KDAB, a developer and mentor at KDE and a top ten contributor, moderator and administrator on the Qt community forum QtCentre.org.

He's also know bringing fine Austrian chocolate to whereever he goes and preparing feasts for his friends.


Room: C1
Title: C++ Conferences Presenter: Jens Weller

I've been to various C++ Conferences and also do organize my own conference and user group. I would like to give a short overview of existing C++ Conferences and give a some details on C++Now, CppCon(which just happend) and Meeting C++.

Presenter Bio: Jens started with programming C++ back in 1998, he joined in 2002 Vodafone as an apprentice and joined in 2005 the Vodafone Testcenter. He has worked since 2007 as a freelancer in C++, specialising in consulting, training and programming C++. He is an active member of the European C++ community and the founder of the Meeting C++ platform and conference. Jens is an active supporter of C++ user groups and blogs often about C++.