Qt Technical Track - Session Abstracts
Beginner to advanced topics directly from the developers who make Qt
Session Categories
| Category Name |
Description |
|---|---|
 Discover |
A first look at existing and new Qt technologies. |
 Innovate |
Focused topics diving deeper into Qt features and best practices. |
 Excel |
Advanced topics covering Qt features and programming techniques in depth. |
 Qt Labs |
More informal, hands-on discussions and demo sessions. |
Discover Sessions
A first look at existing and new Qt technologies.
Choosing your UI weapon - C++ vs. QML vs. HTML5
Speaker: No'am Rosenthal
Qt gives you lots of options. You can use QML, you can use traditional C++, or you serve HTML5 in a web view. But with all those options, comes the question - which option is best for my particular user case? What is the criteria that would help me make the choice that is right for me? We will explore this question by trying a few use cases with those three approaches, and by trying to understand the problem each is trying to solve.
Cross-Platform Mobile UI's
Speaker SFO: Riku Valtasola
Speaker MUC: Michael Samarin
Join this talk to learn about our experience in using Qt/QML for making mobile UI's that would work on several platforms, including experimenting with Android. We will use the Qt Developer Days 2011 app as our main example and take an inside look into the process of making this application. In addition, you will hear about other example applications, like WRC Live that works equally well on Symbian and MeeGo.
Internationalization - Translating Applications in Qt
Speaker: Riku Salminen
The talk deals with internationalization as a mindset, rather than technology, when coding for different regions. We will look at some bad examples and introduce some good rules of thumb for internationalization.
Furthermore we will look into localization as a way for attracting more people across the globe and making your app more personal (and it's not only language, we're talking about).
Finally, we dive into coding in practice, including working with translation agencies/services and using crowd sourcing.
Intro to Qt SDK and cross-platform development
Speaker: Tobias Hunger
The Qt SDK supports a wide range of devices. This session explores how to build, deploy and debug applications on embedded linux platforms and Symbian as well as the Qt Simulator.
Location aware apps - positioning, maps, sensors and more
Speaker: Alex Blasche
Modern consumer applications enrich the user experience by providing strong feedback about the user's current situation. This could either be related to the current location, a location where the user would like to go or detecting physical user interaction with the device. This session will give you a head start on developing with these Qt technologies and provides a sneak preview on upcoming features.
Meet Qt and Qt Quick
Speaker: Justin Noel, ICS
Are you fully aware of all you can really accomplish with Qt and Qt Quick? We'll take you beyond the benefits of Qt and Qt Quick from a marketing standpoint and dive into the technical aspects of what they are and how they work together. Justin has been developing Qt apps since Qt 3 and knows all the tricks any up and coming Qt developer might need. We'll cover Qt philosophies and design, object communication, QML items, elements and properties.
Meet Qt Creator IDE
Speaker: Tobias Hunger
In this session, we will provide a very quick introduction to Qt Creator, then dive into the hidden wonders of this powerful and easy-to-use cross-platform Qt IDE, covering features like Quick Fixes, or the new Analyzer mode.
Meet Qt WebKit
Speaker: Alexis Menard
The marriage of WebKit with Qt is still going strong - after more than 2 years! The current version is geared toward mobile content and hybrid applications. This presentation will introduce QtWebKit and address the recently completed features and ongoing projects. Questions and feedback are greatly valued.
Publishing Qt based apps - making money from your work
Speaker: Kevin Chan
Downloads are growing exponentially. New business models will pay an increasingly large role for driving revenue beyond paid downloads. In-App Purchasing is becoming one of the key ways to monetize apps. This session will explain more in detail what it is, how to integrate it into Qt app and publish to Nokia Store.
Publishing Qt based apps - step by step considerations
Speaker: Gordon Thornton
This session will take a closer look on publishing process to Nokia. We will show you common pit falls, and offer tips and good cases on how to pass Q&A smoothly and give an overview on our moderation guidelines. Questions and feedback are greatly valued.
Qt Bearer Management
Speaker: Tero Äijälä
This session will discuss what Qt Bearer is all about, and what use cases a developer can achieve by using the API in their application. It will also cover transition from Qt Mobility Bearer to QNetwork's Bearer, and why it would be a good idea to switch to the new implementation now at the latest.
Qt Quick Components for Designer
Speaker: Jürgen Bocklage Ryannel
Qt Quick Components are ready made UI elements for creating a fluid mobile User Experience (UX) on Symbian mobile devices. The focus will be on the different design aspects of a typical mobile application using Qt Quick Components. Additional, we will present an easy way to sketch your application with wireframe elements. There is no coding involved in this session, it's pure user interface concepts. The "Qt Quick Components Deep Dive" will cover the coding aspects of the Qt Quick Components.
Qt Quick Desginer
Speaker: Thomas Hartmann
I will give an introduction to Qt Quick Designer and explain possible work flows and some of the more advanced features.
Innovate Sessions
Focused topics diving deeper into Qt features and best practices.
3D programming using Qt Quick on N9
Speaker: Sarah Smith
In this practical session you'll see how to write QML to quickly add and animate 3D content in your 2D QML application using Qt Quick 3D. You'll see how to easily deploy it onto the new Nokia N9 to take advantage of OpenGL hardware - which after all was designed for 3D content. The new features available in the recently released packages of Qt Quick 3D will be shown off, and we'll talk about what's coming down the line for the most exciting tool in your Qt Quick toolbox.
Anatomy of real world apps - dissecting cross-platform apps written using Qt Quick and C++
Speaker: Marius Bugge Monsen
In this talk Marius will present an approach to architecting and implementing apps in Qt Quick and C++ that allows both rapid development and scalability. The talk will present architecture and code for real world, high profile apps that are already available in Nokia Store or are under development.
Basic Networking with Qt
Speaker: Markus Goetz
This talk will introduce you to Qt's networking classes. It will show how you can use TCP sockets and servers, HTTP and UDP sockets with Qt. It will explain how you can architecture a Qt application that is using the network. At the end of the talk we will have created a Qt application that uses all of this functionality.
Dance, Dance QML Revolution - Using Qt for MeeGo development
Speaker: Justin Noel, ICS
Dance Dance Revolution was a very popular dance game back in the late 1990's and early 2000's. Then, in 2005, an open source version of the game, called "StepMania" was released. This brought the popularity of Dance Dance Revolution back with a small, but strong fanbase. However, StepMania was developed for the desktop environment and uses "SDL" which uses the desktop version of OpenGL, limiting its portability. Therefore, a QML port has the following advantages: It can run on mobile devices like cellphones and tablets without having to worry about differences in capabilities; it can natively handle multi-touch and other types of input easily; and it can also run things like video and animation natively. This presentation will cover what was needed to complete this port, what issues arose and things to think about in game development using QML.
Deploying Qt applications to iOS
Speaker: Ian Dean, Freelance / Qt iOS Port Maintainer
In the past four years, the Apple® iPhone and iPad have revolutionized the design of mobile devices. Using their own proprietary frameworks and programming language, Apple has also changed the market for mobile applications. Until now, there has been no easy way to port existing Qt applications to Apple mobile devices, or to develop cross-platform mobile Qt applications that can be run on Apple mobile devices. This talk will give an overview of the community and commercial ports of Qt to Apple iOS devices, and walk you through the steps required to deploy a Qt application to iOS.
eT-Kernel from eSol
Speaker: Masaki Gondo, eSol
Now Qt is spreading over ever more increasing type of embedded devices, due to its excellence as an application framework and cross-platform nature. However, the embedded systems present different kind of challenges from those of desktop, PCs, such as real-time processing and reliability. Increasing intelligence in such systems prompts need for such framework as Qt and underlying OS that is real-time and reliable. Qt on eT-Kernel is full port of Qt onto eSol eT-Kernel RTOS, offering full POSIX interfaces and TRON interfaces, with multi-core capability. This talk will introduce the Qt port and eT-Kernel, and discuss how this blend of real-time OS with Qt differs from that of generic OS such as Linux, along with some of the advantages it brings.
Getting your Qt app running and deployed on Symbian
Speaker: Andreas Jakl
Qt is marvelous as it eliminates the need for most of the platform specific knowledge and allows deploying the same source code as native apps to multiple systems. However, in few areas the underlying operating system still shines through - a good example is the security framework. In other cases, you need to handle use cases that are not covered by Qt APIs. Therefore, it's good to know about the system environment as a developer targeting Symbian. A good understanding of the Symbian ecosystem is also needed to approach the wide array of Symbian devices in the market, which range from older low-cost devices up to the latest high-end Symbian Belle Smartphones.
Graphics performance - Best practices
Speaker: Kim Kalland
This talk will discuss the strengths and weaknesses of the raster and OpenGL paint engines, how some of the Qpainter features affect performance, what APIs to use and how to structure your painting code to create applications with good graphics performance.
How to integrate multimedia into your Qt app
Speaker: Jonas Rabbe
Multimedia is of vital importance in modern app development, be it sound effects for games, streaming videos from the internet, or the next make-your-pictures-look-old-and-weathered camera app. This session aims to help you understand the toolbox available for multimedia in Qt and introduce its use.
HTML5 in QtWebKit
Speaker: Alexis Menard
HTML5 is the new frontier of Web development. This new standard is being created to push the web beyond the limit of HTML4 and to enable rich application in the browser. This talk presents some new features of HTML5 that are already availbale in QtWebKit and how you can use them when mixing with C++.
Hybrid Development with Qt WebKit
Speaker: No'am Rosenthal
Hybrid is no longer an experimental feature or idea. Many developers use HTML5 as part of their native applications in the mobile, desktop and embedded space. In this session, we will get a head start on how to approach this development technique with Qt, how to embed a web view in a C++ or QML application, and how to expose local functionality. We will also look into the future and explore what hybrid development will look like going forward.
INTEGRITY from Green Hills Software
Speaker: Rolland Dudemaine, Green Hills Software
The Green Hills INTEGRITY Separation Kernel is an established, and mature commercial Real-time OS solution for the embedded market that has a growing market share. INTEGRITY and Qt Commercial naturally complement each other with Qt bringing advanced graphics to our INTEGRITY based platforms.
This talk will present the straightforward method used to realize this port, interesting considerations found during the work, and use cases for Qt Commercial on INTEGRITY.
Multi-screen development with QtQuick
Speaker: Donald Carr
Qt Quick maps very nicely to large screen devices. Its innate bias towards pixmap based UIs is highly accelerateable and allows for the rapid construction of compelling competitive modern UIs. One does not have to be at the state of the art in this field for very long before establishing just how tailor-made the language is for this domain, despite its clear primary focus on touch based UI/interaction and mobile devices. This session covers the design and implementation of Qt Media Hub (http://gitorious.org/qtmediahub/qtmediahub) across a variety of hardware domains and form factors, and the challenges/merits associated with using QML as a foundation for this kind of application.
Pimp your UI - Using effects, transitions, etc
Speaker: Johannes Zellner
This session shows how to visually enhance Qt Quick applications by adding bling and animations to your UI. The talk will focus on base QML elements and gives ideas how to pimp UIs only with the simple elements, which are shipped with current Qt versions.
Using Qt to develop games for Nokia devices
Speaker: Mika Pesonen, Jani Vaarala
Developing high performance Qt games for Symbian devices can be a challenging task. This session will help you identify key problem areas in Qt Symbian game development and provide solutions for these. The presentation will cover audio latency, graphics architecture, graphics performance optimizations and direct EGL & OpenGL ES usage in Qt.
Qt Networking - Web services
Speaker: Peter Hartmann
Web Services offer a flexible way to use data from the Web; this talk focusses on who offers such data (e.g. Facebook and Twitter), what techniques are typically used (e.g. Oauth and JSON) and, of course, how to use such data with Qt.
Qt Quick Components Deep Dive
Speaker: Ruben Rincon
In this session, you will be presented key concepts behind creating applications with the new Qt Quick Components for Symbian and Meego platforms. Qt Quick Components is a set of ready-made UI building blocks with native appearance. Among the topics covered you will find a brief walkthrough the different components, concepts of navigation and memory management and how to create your application consistent with the UX guidelines for Symbian and MeeGo platforms from a programming perspective.
Targeting Android with Qt
Speaker: Espen Riskedal, Cutehacks
In the last two years, Android has become one of the most popular smartphone platforms in the world. In the same time, Qt has developed an elegant and mature solution for creating mobile apps with Qt Quick. Necessitas is a community project that adds Android support to the Qt SDK. This talk will explain how you can deploy your Qt app to the Android Market using Necessitas.
Using Qt mobility to develop NFC apps
Speaker: Andreas Jakl
With Near Field Communication (NFC), your phone transforms into a haptic device that reacts to touching gadgets, other phones or Smart Posters. To speak through a Bluetooth headset, just tap it. To connect to your friends on social networks, touch your phones. To get more info about a statue in a museum, simply tap the info panel. In this session, you will learn how to create those experiences using Qt Mobility. How can you extend your app to make use of NFC - to either simplify your existing interaction patterns, or to create unique new features that make your app stand out from the crowd. We will investigate the available APIs and walk you through the steps required to start coding with NFC.
Using Qt Quick for Rapid UI Prototyping and Development
Speaker: Jens Bache-Wiig
Creating an application with a great user experience is a challenge. Traditionally a lot of effort goes into upfront design where tools such as Flash or PhotoShop are used to prototype ideas and real problems are found only after the application has been implemented. Qt Quick turns this problem on its head. Now the UI designer can rapidly prototype a design and instantly try out new ideas. In this session you will see a mobile App being created from scratch. See for yourself how designers can try out their ideas, test on a mobile device and rapidly iterate towards a polished final product.
Excel Sessions
Advanced topics covering Qt features and programming techniques in depth.
Combining Symbian and Qt API's for mobile app development
Speaker: Tapani Puhakka, Teleca
Join this talk to learn about our experience in developing Qt applications for Symbian^3 platform, including multiple music applications featuring real-time mixing and live streaming. While the Qt APIs are robust and comprehensive, there are still gaps, which need to be filled by using the native platform APIs. You will hear about our experiences, workarounds and solutions for implementing complex application experiences for the Symbian platform.
Creating performant Qt Quick apps
Speaker: Volker Krause (MUC)
Speaker: Romain Pokrzywka (SF)
Working in resource constraint environments poses a range of performance challenges and tradeoffs. Application startup time, CPU usage and power consumption, memory footprint, I/O load, graphics and animation smoothness and architectural and implementational complexity all need to be taken into account. This presentation will show the impact of the way Qt Quicks is implemented in Qt4 on these factors and offer guidance on what choices developers can make to achieve optimal performance in their unique set of circumstances and on their target hardware.
Deep Dive into MeeGo and the Nokia N9
Speaker: Yoann Lopes
The Nokia N9 is the first phone running MeeGo and as you might know, Qt is at the center of this platform. It provides a great set of tools and libraries that make this device very accessible and give a formidable way to learn Qt development not only for MeeGo, but also for other mobile platforms. In this presentation you will learn everything you need to know about how to make a Qt application for the N9 and how to make the most out of the development tools.
Development of Multi-threaded applications
Speaker: Olivier Goffart
In this talk, we will go over pieces of code written with Qt in order to explain some of the patterns that are useful for writing multi-threaded applications. In particular, we will introduce some lock-free algorithms, and even dig into the implementation of QMutex for a better understanding.
Getting the most out of QtMultimediaKit on mobile
Speaker: Gareth Stockwell
While the capabilities of modern mobile device hardware are progressing fast, they can still be challenged by the demands imposed by advanced multimedia applications. This means that, although QtMultimediaKit provides powerful cross-platforms abstractions, the developer needs to keep one eye on the constraints of the mobile target. This session will provide advice and tips on how to write compelling multimedia apps for mobile platforms.
Qt In-Depth
Speaker: Janne Anttila
Through examination of the key internal of the Qt framework, this session will help you better understand what is happening deep inside Qt. The presentation will cover the internals of Qobject with its signals and slots, principles and use of the p-impl design pattern, atomic reference counting, the Qt event loop and the event processing mechanism, and the implementation of implicit sharing. It will cover a wide range of topics at a fast pace.
Qt Quick Best Practices and Design Patterns
Speaker: Girish Ramakrishnan
There is no better way to learn new technology than by reading existing code. As Qt Quick is a fairly new technology, existing QML code contains many different programming styles and coding techniques. This talk will discuss various QML best practices and design patterns for building powerful and scalable Qt Quick applications with QML and C++ code.
Secure Networking with SSL
Speaker: Peter Hartmann
This is an in-depth talk about using SSL with HTTP and beyond, focusing on client-side SSL with Qt. There will be an introduction to Qt's SSL API and features, as well as general SSL overview.
The last mile - Effective Debugging and Profiling for Qt and Qt Quick
Speaker: Till Adam, KDAB
Qt and Qt Quick make it quite easy to realize applications, libraries and services rapidly and with a rich feature set. The abstractions and layers that facilitate this can make it challenging, however, to effectively find and eliminate problems in both functionality and performance. This presentation will highlight tools and techniques that have proven their value in the trenches of real world projects across a wide range of platforms, target systems and domains.
Qt Labs Sessions
More informal, hands-on discussions and demo sessions covering up-and-coming Qt technologies.
How to do Qt contributions
Speaker: Marius Storm-Olsen, Thiago Macieria
In 2010, Nokia started working on the Open Governance model for Qt and related projects. The Open Governance model turns Qt into a full Open Source project, with all positions in the project availbale to anyone in the community regardless of company affiliation. Contributors can now participate directly in the development of the project, and help shape the direction of the Qt project. This session will present how the Open Governance model differs from the previous Contribution Model, what the guiding principles are, then follow with a hands-on approach to how the community is expected to work from now on. We will also discuss how to make contributions to Qt, starting from obtaining the source code, to having it landed in the code repository, and interacting with other contributors to improve the contribution. The presenters will also discuss how one can contribute to Qt without being a code developer, showing what other possibilities exist and where help is welcome.
Persistent Object Storage for Qt Quick
Speaker: Jamey Hicks
In Qt5, Qt Quick is the center of Qt. This talk describes a persistent object system tightly coupled to Qt Quick, enabling rapid creation of data models matching JavaScript and QML object representations. This talk will describe how to use it in your applications, and how to quickly import data from other sources.
QPA - The Qt Platform Abstraction
Speaker: Thomas Senyk
QPA - The Qt Platform Abstraction is an upgrade an replacement for Qt for Embedded Linux (Qt/E). Although Qt/E has a lot of nice features and benefits (for example no external dependencies) it also has some major drawbacks (for example the strong binding to the software-painengine). This talk will explain the differences between QPA and QWS, QPA's architecture and where and why QPA is your weapon of choice. You will also see some real examples showing you how you can start your own Qt-port using QPA.
Qt 5 roadmap - Getting into the details
Speaker: Lars Knoll
The Qt Project is the newly formed open source project that emerged from the open governance effort that has been ongoing in Nokia for over a year.
It is a way that will allow every individual and company that has an interest in Qt to help with its ongoing development and contribute in the areas that are of special interest to them.
The talk will explain, how these contributions happen, what kind of expectations the project has towards contributions and contributors, and how a roadmap can emerge from the sum of these contributions.
Qt Quick 3D
Speaker: Daniel Pope
During this session, you will be introduced to Qt3D and its extension into QML - QtQuick3D. The inner workings of the framework will be briefly investigated, and a practical demonstration of Qt3D/Quick3D in action will show you how quick and easy it is to get up and running in the world of 3D using Qt. The content of this session is aimed to complement what you'll see and learn in the later session on 3D programming for the N9.
Qt Quick Components for Desktop
Speaker: Jens Bache-Wiig
Qt Quick enables rapid development of fluid mobile UI's. This presentation introduces you to a new set of desktop components being developed for Qt Quick that will make it possible to create native looking desktop applications. We will demonstrate how you can already make use of them in your applications and invite you to discuss various aspects of their design.
Using Qt Quick and the new Qt graphics stack, Scene Graph
Speaker: Kim Kalland
QML Scene Graph is a new OpenGL based graphics stack which will replace QGraphicsView and Qpainter as back-end for Qt Quick. This talk will explain how to implement customer, Scene Graph based QML elements from scratch and how to port existing QGraphicsView based elements to Scene Graph. Say goodbye to Qpainter and welcome vertices, shaders and textures.
WebKit 2 - Looking forward
Speaker: Pierre Rossi
In little over a year, WebKit2 managed to make its way into several browsers already, both on mobile platforms and the desktop. Like many other ports, and with the first hand experience acquired while doing the N9's browser, QtWebKit is now gearing up to provide a WebKit2 API in the context of Qt 5. Come find out more on the future of QtWebKit.
What's new in QtQuick 2.0
Speaker: Bea Lam
Qt Quick 1.0 brought a suite of technologies to make it easy for designers and developers to easily create fluid animated interfaces that integrate seamlessly with C++ applications. QtQuick 2.0 takes this further with the introduction of a built-in Scene Graph rendering system, a particles effects system, JavaScript engine optimizations for QML, a Canvas API and more. This presentation gives an overview of these features and discusses what's next for Qt Quick.
