Keynotes

Breaking Down Technology & Application Silos
Qt at the Forefront of Future-Proof Modern Application Development

Speaker: - Tommi Laitinen, SVP International Products, Digia Qt

Abstract:
As application development continues evolving at a rapid pace developers are faced with a myriad of platforms competing for their affection. At the same time, developers and enterprises encounter functionality, performance and development-effectiveness dilemmas where end-user requirements for next-generation UIs and core backend logic are high. At the same time, cross-channel interaction is a must-have to secure software investments among competing ecosystems and platforms. Tommi Laitinen will give an overview of the development that has happened with Qt in the past year and describe how Qt’s mature architecture is at the forefront of future-proofed multi-platform application creation in today’s converging technology arena. Tommi will further touch upon the opportunity space and future investments in Qt. Lastly, he will explain how Digia is expanding the Qt ecosystem, its market opportunity and making Qt available for everyone everywhere.

http://devdays.kdab.com/?page_id=225

Speaker Bio:
Mr. Tommi Laitinen SVP International Products of Digia is responsible for Qt and Digia’s international product business. He has been at Digia since 1999, and is a member of the company’s management team since 2005; SVP of Competence organization (2009-2010), SVP of Telecommunication division (2007-2008), SVP in charge of the company’s strategy and development (2005-2007), Vice President, Engineering (2002-2004), Director, Quality and Processes (2001-2002) and Business Unit Manager (1999-2000). Tommi has over 15 years of experience in developing Internet and mobile applications and services. He also has a long experience with start-ups, working as a board member and advisor.

The Qt Path
Where We are and the Technology Direction Ahead

Speaker: - Lars Knoll, CTO, Digia, Qt & Qt Project Chief Maintainer

Abstract:
Lars Knoll will give a detailed technical overview of Qt’s development process in the past 12 months together with the Qt Project. He will focus on the upcoming Qt 5.2 release and provide details on the final versions of the Qt for Android and iOS ports as well as other key functionality. In addition, Lars will explain Qt’s web strategy and how Qt WebKit and the recently announced Qt WebEngine fit your current needs and solidify the future for innovative, interactive, highly-performing web development. Lars will conclude with a walk-through of the Qt roadmap presenting the top new features and functions that strengthen Qt’s performance, stability and new platforms as we move ahead into 2014.

Speaker Bio:
Lars Knoll is the Digia, Qt CTO and Qt Project, Chief Maintainer. He has been working on Qt for more than 12 years starting as a software engineer to later leading the global Qt engineering team in Nokia before the Digia acquisition in October 2012. Lars has been an active member of the KDE community and the architect behind KDE’s HTML rendering library that formed the basis for the WebKit open source project. Lars holds a PhD in physics from the University of Heidelberg. He is German national and lives with his family in Oslo.

Trains, planes, automobiles… and space shuttles. Going the distance in the high-tech industry.

Speaker: Dan Dodge — Cofounder & Chief Executive Officer, QNX

Abstract:
In the keynote, Dan will share his thoughts on Qt and its relevance for mobile and embedded computing. But mostly he’ll talk about what it takes to build awesome technology year after year for decades, and about the organizational values that matter most to him. This is a rare opportunity to hear from someone who tends to avoid the limelight because it distracts him from what he still really likes to do. Write code.

Speaker Bio:
Recognized for innovation and leadership by organizations like Frost & Sullivan and FORTUNE magazine, Dan Dodge has built a global reputation as a technology visionary. A pioneer in the embedded systems industry, Mr. Dodge has created software that controls everything from in-car infotainment systems and smartphones to nuclear power plants and the world’s highest-capacity Internet routers.

Dan has garnered various tributes, including the Queen Elizabeth II Diamond Jubilee Medal and the prestigious J.W. Graham medal in Computing and Innovation from the University of Waterloo. In 2002 he was acclaimed a Hero of Manufacturing by FORTUNE magazine.

Dan is a passionate advocate of software standards and was a founding steward of the Eclipse consortium, an open-source software initiative.

Dan holds a Master’s degree in mathematics.

Python 3 and Qt 5 with QML

Presenter: Thomas Perl – thp.io

Short Abstract:

This presentation highlights the history of Python-on-Mobile development (PySide, Python 2 with Qt4), followed by a quick reality check of real-world mobile Python applications and their shortcomings, and then presents a novel approach to use Python 3 and Qt 5 with a custom language binding framework that’s tailored to the Python-QML use case to create fluid, non-blocking and powerful mobile applications with Python 3 and QML using Qt 5.

Abstract:

Python (http://python.org/) is a popular programming language that is easy to learn and widely-used. It is used not only for server-side web development, but also for tooling, automation, testing and application development. In recent years, it has been increasingly used for mobile application development as well, first with PyGtk and more recently with PySide/PyQt and QML. In this presentation, we will first highlight how PySide/PyQt has been used historically with Python 2 and Qt 4 to create mobile applications such as gPodder, and then explain the d

ifficulties and shortcomings of this approach as it relates to “”pure”” QML applications.

In the second part, a new, custom language binding is presented that works with Python 3 (Python 2 is also supported for those who can’t switch to Python 3 yet) and Qt 5 (Qt 4 is also still supported). While not API-compatible with PySide/PyQt, the focus on making the API work well for QML user interfaces that need a Python backend allows for a much smaller memory footprint (both runtime and download), quicker startup times and asynchronous request handling (so calls into Python never block the QML UI).

As an example of porting existing Python applications from PySide/QML to the new binding framework, we then analyze the port of gPodder from PySide to the new framework, and compare startup time, download size, memory footprint and UI responsiveness.

Presenter Biography:
Thomas Perl is an Austrian computer scientist and independent developer. He has been working with Python since 2005 and Qt since 2010 (before that, he’s been working with Gtk+ since 2005). In recent years, Thomas has developed some cross-platform applications such as gPodder, which runs on Desktop and mobile devices, written completely in Python with a QML user interface on mobile. Thomas is a regular at Vienna’s monthly Python User Group Meetup (PyUGAT) and has written tutorials and given talks about how to best use Python for development on mobile devices.

Presentation

Developing Embedded Linux Applications with Qt

Presenter: Andy Nichols – Digia

Short Abstract:
Embedded Linux application development is not simple, but that doesn’t mean that it has to be hard. Qt 5 provides most of the necessary middleware for your application, but how do you get it running on your device. This presentation will demonstrate from start to finish how to obtain the tools necessary to build for a given device, to running and debugging from Qt Creator.

Abstract:
“Before you can develop any application for Embedded Linux you need the following things:
device:

You need some hardware that supports the needs of your application. With Qt 5 this will generally mean an ARM CPU with a GPU core with OpenGL ES2 support.

image:
You need an image for the device to run. This will include the bootloader, kernel, and userspace filesystem.

sysroot:
On your development machine you need to have a sysroot which contains the development files corresponding to what is on your device image.

toolchain:
On your development machine you need to have a compiler capable of generating binaries that can be run on your device.

This presentation will demonstrate from start to finish how to obtain the tools necessary to build for a given device, to running and debugging from Qt Creator. The Raspberry Pi will be used to as the reference device so that the techniques used in the demonstrate can be reproduced easily. Buildroot will be used to generate a toolchain, sysroot, and image customized for our hardware and use case. I will show how to hook these generated tools into an existing installation of Qt Creator, and how to build, deploy and debug from a remote machine to the Raspberry Pi.

In addition I can discuss some of the best practices when developing for Embedded Linux with Qt, as well as some of the pitfalls to avoid.

Presenter Biography:
Andy Nichols is currently a software engineer at Digia in Olso, Norway. He has worked with Qt for the last 7 years. Andy was a Qt support engineer at Nokia for 3 years who focused on customers using Qt for embedded Linux. He later took a role as a software engineer at Nokia with the Qt graphics team where he worked on the Qt Platform Abstraction (QPA) in Qt 5 as well as the QtWayland module. Since joining Digia he has been focused on Wayland, Multimedia, and the Embedded Linux and iOS ports. Andy is the maintainer of the QtWayland module.

GitHub

Targeting multiple mobile platforms with Qt Creator

Presenter: Aurindam Jana – Digia

Short Abstract:
Application development for mobile devices with Qt looks more promising than ever before with the possibility to targets platforms such as Android, Blackberry, iOS, SailfishOS, Ubuntu. With the latest Qt Creator, application developers can seamlessly develop, deploy and debug applications on their favourite platforms. With the new Qt Quick Controls and their integration with the Qt Quick Designer, creating beautiful UIs has now become a more pleasant experience. The QML profiler now shows more information regarding paint events and memory usage. The presentation will focus on setting up the developer environment, creating simple applications for Android, Blackberry, iOS and SailfishOS and strategies for code portability and maintenance.

Abstract:
Application development for mobile devices with Qt looks more promising than ever before with the possibility to targets platforms such as Android, Blackberry, iOS, SailfishOS, Ubuntu. With the latest Qt Creator, application developers can seamlessly develop, deploy and debug applications on their favourite platforms. With the new Qt Quick Controls and their integration with the Qt Quick Designer, creating beautiful UIs has now become a more pleasant experience. The QML profiler now shows more information regarding paint events and memory usage.

The presentation will focus on setting up the developer environment, creating simple applications for Android, Blackberry, iOS and SailfishOS and strategies for code portability and maintenance. The presentation will be a hands-on demo with actual devices.

Presenter Biography:
Aurindam has an engineering degree in Electronics and Communication. He has spent the last seven years developing software for mobile platforms. He has been using Qt for more than four years and has been contributing to both Qt and Qt Creator. He also codes on iOS during his free time. He has a keen interest in football and adventure sports

Presentation

Qt vs OpenGL – Embedded

Presenter: Thomas Senyk – Pelagicore

Short Abstract:
With Qt 5 and the embedded hardware of today, hardware accelerated graphics become more and more important. In this session you will learn about the OpenGL stack and how to access OpenGL from Qt. We also look at optimization as well as tips and tricks.

Abstract:

On new embedded hardware it can be challenging to enabling Qt to use OpenGL properly. This talk is an introduction into the basic terminology, explaining the roles and duties of the different technologies involved and how to enable them for Qt to be used. This talk will also cover an overview of the possible optimizations within Qt.

This talk digs deep into the different platforms available through Qt. In-depth discussions of X11, EGLFS, directfb and Wayland are followed by common problems and available work-around options. All is done with hands-on examples and real code.

Presenter Biography:
Thomas Senyk has worked at Nokia from August 2009 to June 2012 as a Professional Services Engineer in the Qt Development Frameworks team.
Thomas is an active software developer since over 9 years. While at Nokia he gained a lot of experience with Qt, and specifically hardware accelerated graphics, on embedded systems in various industries, for instance automotive and home media.
Since July 2012, Thomas is working for Pelagicore, which gave him the opportunity to further improve his skills in the field of Qt in embedded system, specifically in the automotive segment.

Presentation

A Qt-based GENIVI Stack

Presenter: Johan Thelin – Pelagicore

Short Abstract:
The GENIVI alliance has made Linux and open source a viable option within the automotive infotainment industry. Given the needs in this market, Qt is one of the tools available to build user interfaces. In this talk, we look at how Qt fits into the picture, but also the tools and standards to relate to.

Abstract:

The GENIVI alliance has made Linux and open source a viable option within the automotive infotainment industry. Given the needs in this market, Qt is one of the tools available to build user interfaces. In this talk, we look at how Qt fits into the picture, but also the tools and standards to relate to.

For instance, we dive into GENIVI compliance, the Yocto project, the Pelagicore platform and APIs. We also look at the wide range of deployment scenarios available, as well as the trends in the market. The changes range from hardware / software separation to the consequences of allowing the users to download apps. All of this changes the playing field and offers new challenges and opportunities.

Presenter Biography:
Johan Thelin has worked with Qt for more than 10 years. He is the author of the Foundations of Qt Development, the Qt in Education training material, numerous articles on-line as well as in printed publications. He currently works at Pelagicore, building the next generation in-vehicle infotainment framework based on open source software.

Presentation

Integrating QtQuick with 3D renderers

Presenter: James Turner – KDAB

Short Abstract:
QtQuick provides a modern 2D UI framework, rendered using OpenGL. In a wide range of applications and fields, this UI needs to be combined with existing rendering technologies and libraries, ideally in ways that minimise the impact on performance while still allowing the full feature set of Qt to be exploited.

Abstract:
“QtQuick in Qt5 uses OpenGL to deliver fluid, performant visuals, and an internal scene-graph structure to permit threaded rendering, decoupling the main application thread from interacting directly with the graphics driver. For developers work with an existing rendering or visualisation technology, this presents both an opportunity but also problems; QtQuick offers a compelling, modern 2D UI with many advantages.

Unfortunately most existing rendering libraries make strong assumptions about how they permit other code (such as Qt) to integrate with their rendering loop and data, and Qt Quick itself was not designed to support efficient integration into foreign rendering environments.

In this presentation will will investigate some of the problems, work-arounds and ultimate solutions encountered in integrating Qt Quick with different 3D renderers, including the changes necessary both in Qt and on the 3rd-party side. This will involve material on threading, OpenGL state management, and the internals of both Qt Quick and scene-graphs in general. To motivate the discussion, some real-world cases will examined and presented, including integration of Qt Quick with OpenSceneGraph, the Visualisation Toolkit (VTK) and (time-permitting) the Open Source Graphics Engine (OGRE).

Presenter Biography:
Working as a software developer at KDAB. James has been developing with Qt since 2002, and contributes to the current maintenance of Mac platform support, and the development of OpenGL and 3D support in Qt. James has a background in user-interface, graphics and simulation development, as well as a long history of development on OS-X and prior versions of Mac OS. He is a lead developer on FlightGear, the open-source flight simulator, and holds a B.Sc. in Computer Science.

Presentation

Practical QML

Presenter: Burkhard Stubert – Embedded Use

Short Abstract:
What topics entail the liveliest discussions when you talk to the makers of in-vehicle infotainment systems, agricultural driver terminals or set-top boxes about building QML GUIs? No, it is not about “”fluid”” multi-touch UIs with graphical “”wow”” effects, but about mundane things like key navigation, theming, and internationalisation. I’ll address these three problems in my talk.

First, I’ll discuss how to navigate QML GUIs solely with a rotary knob. By turning or pushing the knob, a “”cursor”” is moved from one QML component or one screen to another. I’ll show solutions for these normal scenarios as well as for trickier ones, where components yield the focus to other components temporarily.

Then, I’ll show you how to switch between day and night themes at run-time. Finally, I’ll explain how to switch between different languages at run-time, internationalise on-screen keyboards and convert between metric and imperial units.

Abstract:
Demos, talks, blog posts and especially sales pitches about QML show the bright side of QML: how easy and quick it is to build “”fluid”” multi-touch UIs with graphical “”wow”” effects – best in 3D. Without doubt, QML shines there. However, once we start developing our QML GUI, we’ll find ourselves fighting with more mundane problems: how to navigate the QML GUI with a rotary knob, how to switch between day and night mode, how to switch dynamically between different languages, how to write well-designed QML components or how to write resolution-independent QML GUIs.

Since the inception of QML, I have been helping customers to build QML GUIs for embedded systems such as in-vehicle infotainment (IVI) systems, driver terminals in harvesters, set-top boxes or home appliances. Sooner rather than later, these customers ran into the problems mentioned above. My talk “”Practical QML”” will give solutions for three of these problems.

First, I’ll discuss how to navigate a QML GUI solely with keys. Think of a car, where the driver controls the IVI system with a rotary knob located in the middle console. The knob sends its events over the CAN bus to the IVI system. By turning the knob left or right, we move a cursor from one button to another inside a toolbar or from a toolbar to a custom list view. By pushing the knob, we bring up a new screen. When we return to a previous screen, the cursor should be at the same position as before. Even these “”normal”” scenarios are not straightforward with QML. And, it quickly gets trickier: for example, when an error dialog pops up while we hold down a plus button, the button must yield the focus to the dialog and regain it when we close the dialog.

Then, I’ll dive into theming with QML. I’ll show how to switch, say, an IVI system at run-time between day and night mode.

Finally, I’ll walk you through the complete process of internationalising a QML GUI with some tips and tricks from the trenches. My focus is on showing how to change from one language to another at run-time. Translating all the strings in an application is only one part of the problem though. We also have to internationalise on-screen keyboards because of their different layouts and to convert metric to imperial units and vice versa.

Presenter Biography:
Burkhard has been working with Qt since version 1.44. He has developed several embedded and desktop applications with Qt including a driver terminal of a forage harvester with QML, a wide-area VoIP phone with Qtopia and IDEs for Bluetooth development and ASIC verification with Qt Classic.

He has worked as an evangelist for Nokia’s Qt team and has convinced well-known companies from the automotive, STB/TV, IP-communications and home appliance industry to use Qt. His customers include Aisin AW, Visteon, Valeo, Free and Loewe. Currently, Burkhard is working as a solopreneur offering professional services for developing connected embedded systems – preferably with a QML GUI and Qt/C++ middleware.

Burkhard worked and lived in India, England and Norway and moved back to his native country, Germany, a year ago. In his spare time, he is hiking and biking through the hills and valleys around Stuttgart.

Presentation Code

Building 3D OpenGL Scenes with Qt 5 and QML

Presenter: Krzysztof Krzewniak – ICS, Inc.

Short Abstract:
This presentation is intended as an introduction for everyone looking to combine the flexibility and ease of use provided by QML with the low level rendering performance of modern OpenGL. We will show you how easy it is to tap into the OpenGL rendering context used by QSceneGraph and have a “pure” OpenGL scene rendered underneath, over or even side-by-side of your regular QML controls.

Abstract:

Since Qt 5 and QML 2.0, OpenGL has become an integral part of Qt’s rendering engine. Be it your regular desktop or an embedded platform, Qt now takes advantage of your graphics hardware to provide a smooth and rich end user experience. Combine that with the expressive powers of QML and you have a killer combination. This sky is the limit, or so it would seem.

What if you would like to create a full 3D user interface? One would imagine that, since we are already using OpenGL, using QSG (QSceneGraph) to work with 3D geometry rather than just plain 2D would be straightforward. Using QSG to work with 3D geometry is indeed possible, however, from my perspective it is unfortunately, far from a pleasant experience.

What about Qt3D?

Well the simple answer is “it is not there yet” and we will not see it released until at least Qt 5.2.

So why are you stuck trying to make QSG bend to your will?

Should you abandon hope of using QML for 3D applications, until Qt3D is available?

We will address the techniques and the steps involved to provide a desirable alternative within the construct of the tools available.

    This presentation will cover:

  • Using the QQuickWindow’s OpenGL Context to render 3D objects under/over your QML scene
  • Handling the camera from QML
  • Adding 3D scene content using QML
  • Using framebuffer objects to write filters for your scene
  • Rendering your 3D objects into a QQuickItem

b>Presenter Biography:
Krzyrztof works as a software engineer at Integrated Computer Solutions, Inc. (ICS) and holds a M.Sc. in Computer Science from the Czestochowa University of Technology. Krzysztof has always had a strong preference towards C++ and the *nix ecosystem. He has been passionate about Qt during the course of his studies and has used Qt to develop for mobile, embedded as well as desktop applications. He was also a member of the Qt Ambassador program.

Presentation

Qt 5.2’s QML engine in depth

Presenter: Simon Hausmann – Digia
Short Abstract:

The QML module in Qt 5.2 comes with many changes, the biggest one being the replacement of the JavaScript engine. This presentation will outline the underlying motivation for the new engine as well as the current implementation state. Building on that, this presentation will also cover the vast opportunities for optimizations that we can leverage for the module in the near future.

Abstract:

Qt 5.2 brings about many changes in the black abyss that is the QML engine. The most significant being the replacement of the entire JavaScript engine, from the external V8 engine to a new engine that is written in Qt – tailored specifically to QML’s need for fast binding evaluation when properties change dynamically. This improved engine allows us to take advantage of important aspects of the QML language that were previously unreachable: The grammar is a superset of JavaScript. Therefore we can parse both QML type definitions and its binding expressions in one go. Unlike pure JavaScript, QML is intrinsically aware of types at compile time, enabling the engine to choose the best approach for calculations early on. These are just two examples of many design aspects we have either implemented in Qt 5.2 or intend to accomplish in the future. This presentation will give an overview of how the QML engine as a whole works under the hood, how we got there in the first place and how we intend to shape it in the future. It is ideal if you’re a curious developer who likes to dabble with the nitty gritty details. It is also a great opportunity to gain plenty of confidence in QML as a future-proof technology.

Presenter Biography:
Simon Hausmann is a software engineer with a passion for open source and small empowered teams. A German export to the Norwegian software industry, he has contributed to various projects over the years such as core Qt modules, the Qt port of WebKit, the git version control system and KDE. These days Simon works mostly on QML and web engine related projects at Digia.

Extending Qt Creator

Presenter: Tobias Hunger – Digia Germany GmbH

Short Abstract:
The Qt Creator powerful Integrated Development Environment tailored to Qt development. But no IDE is perfect.

Ranging from configuration, via macros up to writing your own plugins, this presentation shows how to adapt Creator to better suit your needs or the needs of your development team.

Abstract:
Qt Creator is designed to be extensible. I want to show various ways that can be used to integrate 3rd party tools and to extend or change existing functionality.

Topics:

  • Configuration: many things are already there and just need to be turned on,
  • Macros: How to use write them, how to use them,
  • Custom Commands: Run custom commands during build or deployment
  • External tools: A convenient way to use external tools in various ways
  • Task list plugin: Getting issues into Creator.
  • SDKtool: Standardized setup for multiple developers.
  • Shared settings: Commit default configurations for your projects.
  • Version control hooks: Not directly QtC related, but can do nice things when used e.g. together with task lists;)
  • Custom plugins: Full control!

There are quite a few things that can be done, that most users are not even aware.

Presenter Biography:
Tobias Hunger is a german computer geek with a degree in Technoinformatik (computer engineering) from the university of Kaiserslautern, Germany.

Tobias is a long time contributor to open source projects such as KDE. He is using Qt in a professional setting since 2006 and became part of the Qt Creator team in Berlin when he joined Nokia in 2009. He works for Digia Germany since September this 2012.

Tobias has implemented core features of Qt Creator like Target support and now Kits and is maintainer of the version control systems plugins of the IDE.

Presentation

Introduction to Qt Quick Controls

Presenter: Jens Bache-Wiig – Digia

Short Abstract:
This presentation introduces you to the Qt Quick Controls and other related modules. We will demonstrate how to make use of them in your applications and invite you to discuss various aspects of their design.

Abstract:
With Qt 5.1, we are introducing a range of new features to make life easier for developers who want to develop Qt Quick applications for the desktop as well as on mobile devices. The new Qt Quick Controls module gives you access to a wide range of ready-made controls such as buttons, sliders, splitters and tabs. In addition, we are adding related functionality to improve the control of layouts and creation of standard dialogs. This presentation aims to give a brief introduction to the most important aspects of these new modules and to demonstrate how you can easily make great desktop applications with Qt Quick in Qt 5.1.

The presentation consists primarily of live coding using Qt Quick, but should be accessible to anyone with previous programming experience and also covers some of the basics of Qt Quick itself. After this presentation you should have a good overview of how to build applications with Qt Quick Controls and how to best make use of them.

Presenter Biography:
Jens is a Senior Software Engineer at Digia and holds a M.Sc. in computer science from the Norwegian University of Science and Technology (NTNU). He is a pixel perfectionist and likes to focus on styling, platform integration and improving Qt Quick.

Presentation

QML Tricks and Treats

Presenter: Vladimir Moolle – ICS

Short Abstract:
This fast-paced one-hour talk is for moderately experienced QML developers and touches on some of more challenging aspects of QML application development. Some of the areas covered will be: keyboard focus (and visual ways of debugging it), mouse handling tricks, input emulation, QML language scope intricacies, overcoming the limitations of the standard ListView (e.g. the absence of scrollbars) and approaches for developing your own views in C++.

Also covered will be how best to approach collaborative QML application development between graphic designers and programmers and how best to address work separation, how to structure complex, mixed C++/QML applications for ease of testing and packaging.

The various topics addressed will be presented in the context of a single example application, developed in stages during the talk..

Abstract:

The talk will consist of the following:

  1. Building and testing mixed C++/QML applications (a generalized solution): simplified build dependency specification with qmake, sharing libraries between C++ application code and QML plugins, shipping QML modules in Qt resources.
  2. QML language scope (a short but mostly complete walkthrough): the issues and interactions of property names, ids and contexts on QML and C++ sides.
  3. Keyboard focus in QML (the key concepts): using little known features of “focus” and “activeFocus” to your advantage, QML focus scopes and debugging them, emulating keyboard input.
  4. Mouse handling in QML (when the standard Mouse Area isn’t adequate): mouse hover over stacked items, issues with Flickable and some interesting approaches to drag-and-drop.
  5. Custom QML view items (or the notorious inability of ListView to play well with scrollbars): tips for writing custom specialized views in C++ (and a little QML).
  6. Styling QML applications (one possible approach): is clean separation of design and logic achievable with QML?

At the end of the talk, time will be reserved for questions.

Materials will be available following the course and will include slides that will be usable on their own and will contain some extra material for self-study (i.e. a series of QML scope quizzes). The source code used throughout the talk will be available in a public git repository as well.

Some parts of the talk will be based on material developed for the “Effective QML” training course.

At the end of the talk, five minutes are reserved for questions.

The slides will be usable on their own and will contain some extra material fo

r self-study (i.e. a series of QML scope quizzes). The source code used throughout the talk will be available in a public git repository.

Some parts of the talk are based on material developed for the “Effective QML” training course, an earlier version of which was taught at Qt Developer Days 2012 in California. The course was also presented internally at ICS in 2013.

Presenter Biography:
Moolle is a Qt/QML software developer for Integrated Computer Solutions, Inc. (ICS), with a specialty in QML he contributes to various speaking engagements including webinars and is co-author of the ICS ‘Effective QML” training course. Vladimir studied at the Baltic State Technical University in Russia, where he earned a specialized technical degree.

Presentation

Apps on Speed

Presenter: Milian Wolff – KDAB

Short Abstract:
Fast code is important – just think of performance constrained embedded platforms. But how do you make your C++ application faster?

This talk will show you how to find bottlenecks in a C++ program using various tools. Then we will look into some solutions to common issues and top it off with some guidelines for new code.

Abstract:
Often one might think: Machines get faster and faster, thus it gets less and less important whether my code runs fast or not.

False! Making your applications faster is more important than ever, especially when you target embedded devices or battery powered devices. And even on the desktop your users will appreciate fast applications that do more in less time.

In the talk I’ll present the most useful tools I know for investigating the performance of a C++ application. We will look at various issues, such as memory consumption, finding CPU hot spots but also at some more complicated threading related performance problems like lock contention. For each issue I will try to present some motivating code example and show you how to improve your code to achieve a better performance.

Presenter Biography:
I work at KDAB as a Software Engineer and contribute to KDE for quite some years now. There I am one of the most active contributors to KDevelop and Kate. Tooling in general is of huge interest to me, I wrote the Massif-Visualizer, played around with a GDB based profiler called Pace and also looked into tooling around Linux malloc to investigate memory fragmentation issues. At KDAB I also worked on GammaRay which is invaluable to any Qt developer.

Presentation

Design trends, they come and go?

Presenter: Nuno Pinheiro – Kdab

Short Abstract:
Recently, in the computer UI/UX world we have seen a surge of Minimalist design that opposes the skeomorphic trends of late.
It as been considered as an “”authentic design”” surge versus the fake one.
Is this true?

Abstract:
Recently, in the computer UI/UX world we have seen a surge of Minimalist design that opposes the skeomorphic trends of late.
It as been considered as an “”authentic design”” surge versus the fake one.
Is this true?
In this talk, I will try to demystify some of this misconceptions and give a historical reminder to this trends and how UX/UI computer land is similar to other areas of “”traditional”” design.
How come developers should care about this issue and how it affects their work is the last part of this talk. By debating the components versus custom QML design MIX.

Presenter Biography:
Nuno Pinheiro is a graphic designer and illustrator. Specialized in iconography, themes and user interface design. Nuno’s works include general illustrations, UI/UX design, web design, corporate design as well as other works in creative areas. He is known in Linux circles for his work in the Oxygen Project where he is the current coordinator. His computer art is world widespread with KDE on different computer platforms.
Nuno also ventures in to QML land.

Applied Type Erasure in Qt 5

Presenter: Stephen Kelly – KDAB

Short Abstract:
The QVariant class in Qt provides a type-erased and runtime-type-checked type for use in Qt applications. Last year I gave a talk on how the QVariant is implemented, how it works and how to use it. This talk focusses on new features in QVariant coming in Qt 5.2. These new features include a type- erased way to iterate over the contents of sequential and associative containers, user defined type conversions and user defined comparisons. More details about the uses of type erasure in Qt 5 will also be shown.

This presentation will include slides, demos and code snippets. The aim is to educate viewers on the features available and limitations of QVariant. Viewers will have a better idea of how to implement a DSL using Qt after this presentation.

Presenter Biography:
Stephen has been a professional Qt developer for over 4 years and has worked non-professionally with it for over 7 years. At KDAB he has worked with and on the model-view system in Qt 4 and Qt 5, as well as numerous other frameworks within Qt such as the state machine framework, the scripting framework and various UI integration.

Stephen is the maintainer in the Qt project of the itemviews system and the CMake files provided by Qt 5.

Presentation

Analysing and Solving Qt UI Performance Problems On Embedded Hardware

Presenter: Phil Brumby – Mentor Graphics

Short Abstract:
When developing UIs for embedded devices, it is not uncommon to hit performance problems on target hardware – whether the UI start-up takes too long, animation is slow, or the UI isn’t responsive enough. The source of many embedded UI performance problems are system level problems coming from outside the UI layer. This presentation will provide practical help to developers on how to solve these common UI problems on target embedded hardware, looking at and demonstrating tools and techniques to analyse the problem (ranging from the humble printf, to more sophisticated trace tools). This guidance will be backed-up by examples of how the author has used these techniques to solve real-world Qt UI problems.

Abstract:
When developing UIs for embedded devices, it is not uncommon to hit performance problems on target hardware – whether the UI start-up takes too long, animation is slow, or the UI isn’t responsive enough. Unfortunately there can be many reasons for these problems and hence trying to find out what is causing the problem can be difficult and very time consuming. In many cases problems only occur on the target or can be intermittent, making it even harder!

QML profiler can help understand what is happening within the QML execution, and although great at debugging QML, this approach can prove unproductive if the root problem resides outside of QML. Equally important, of course, is that this profiler doesn’t help with Qt Widget based UIs!

The source of many embedded UI performance problems are system level problems coming from outside the UI layer (for example file system problems, back ground processing, interrupts, stalled data processing, CPU loading, etc). Hence it can be more productive to start at the system level, work out what is taking the time within the system and narrow the problem down. The most appropriate tool for the problem area can then by applied (including QML profiler) to debug the problem code.

Equally, if a problem occurs on an irregular basis or after a long period of time, one of the key challenges is identifying when a problem has occurred within, what can be, a large log file or trace data set. Hence it is important to be able to easily analyse, filter and tag trace data, and then zoom in to where performance problems occur.

This presentation will provide practical help to developers on how to solve these common UI problems on target embedded hardware, looking at and demonstrating tools and techniques to analyse the problem (ranging from the humble printf, to more sophisticated trace tools). This guidance will be backed-up by examples of how the author has used these techniques to solve real-world Qt UI problems

.

By the end of the presentation, the aim is that Qt developers will be aware of tools and techniques which can help them resolve what can first seem like complex UI performance issues, and hence help them build better (and consistently better) UIs on Qt.

Presenter Biography:
Phil Brumby is a Senior Technical Marketing Engineer for Mentor Graphics’ Embedded Software Division. Phil has the responsibility for the technical and engineering development for Mentor’s embedded graphics and user interface product offerings. Previously Phil has held a number of senior software engineering roles in the user interface and mobile gaming spaces. Phil holds a Masters degree in Applied Computing and a Bachelor of Science with Honours degree in Mathematics & Statistics from the University of Dundee, Scotland.

Presentation

Expression Templates – or: How I Learned to Stop Worrying and Love Template Meta-Programming – Volker Krause

Presenter: Volker Krause – KDAB

Short Abstract:
Contrary to common perception, expression templates are not bizarre meta-programming theory but something you are (possibly unknowingly) using every day when working with Qt. We’ll see what they are good for, how they work and and what to do if they don’t.

Abstract:
Originally invented by Todd Veldhuizen for the use in the math library Blitz++, expression templates are often seen as one of those esoteric applications of C++ template meta-programming that results in completely incomprehensible code that only a handful of C++ gurus can understand at best, and that gives you compiler errors longer than an average discussion on the right display manager.

In this talk we will try to counter this (wrong) perception, by looking at why and how this (syntactically) indeed somewhat complex code results in very elegant API and often outperforms conventional implementations. On the way we will see that C++ template meta-programming code is actually not that scary, and that template-related compiler errors aren’t that bad either.

Now why would this be of interest to the average Qt developer? Well, since the introduction of QStringBuilder in Qt 4.7 we have expression templates for a very common use case, string concatenations. We will see how this is implemented, why it is faster than previous approaches and what pitfalls you might encounter. So, we are not talking about exotic theory here, but about something you are using every day.

Presenter Biography:
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.

Presentation

QML across all UI stacks – Support for QtWidgets

Presenters: Kevin Krammer and Tobias König – KDAB

Short Abstract:

When QML is the topic it is seen by many as a part of QtQuick.
However, with the introduction of BlackBerry10’s Cascades framework, it has been proven to be a very good option for creating user interfaces, regardless of the library being used for providing the interface elements.

One of the best known and established among those user interface libraries is QtWidgets. It is being used by hundreds of software vendors, deployed to millions of devices, used by an uncountable number of end users.

KDAB’s Declarative Widgets technology enables developers to create QtWidget based UIs through QML, allowing an unparalleled re-use of code and transfer of developer skills between traditional desktop software and their respective mobile versions.

Abstract:
QML has many facets that makes it so attractive for user interface development.

  • The declarative approach makes it easier to understand to non-coders, allowing user interaction experts and designers to work directly on the product instead of just providing input and guidance to developers.
  • Its property bindings and scripting capabilities reduce the amount of custom, usually simple or even trivial, C++ code for just keeping the state or display data of interface elements synchronized with each other.
  • The built-in context property mechanism, which allows easy access to QObject based objects, encourages a clean separation between UI and application logic.
  • If done right, it makes the application logic fully UI agnostic, opening up options such as different interfaces for different user profiles, updates without binary code changes and even network deployment not unlike delivering a web interface to a browser.

QtWidgets, on the other hand, has been used in rather static ways, often deeply entangling UI bits of code with related logic bits. It is, however, a well understood and proven technology with a rich feature set.
Considerable amounts of application code depend on it to deliver traditional desktop computing user experience. On top of that a lot of resources has usually been spent on code for custom widgets or standard widget customization.

In addition to being a company committed to the maintenance of the QtWidgets module, KDAB is also looking into ways to improve the life of application developers using widgets.

The Declarative Widgets framework makes QtWidgets classes available as QML element types, enabling creation of widget based user interfaces using QML syntax and runtime facilities.

It also opens a migration path towards other QML based user interface technologies. A traditional widget based application can be gradually refactored, achieving the UI/logic separation required for a Cascades or QtQuick interface, while at the same time keeping the application’s functionality and look and feel unchanged.

This newly created core application can then in large parts or in full be re-used for mobile or embedded versions of the software or, when ported to Qt5.1 or later, be equipped with a QtQuick controls based UI.

The session will demonstrate the workflow for the former, transforming a traditional widget based application into a core with Declarative Widget UI and then adding a BB10 Cascades interface.

Presenter Biography:
Kevin is a developer and Qt trainer at KDAB and has been actively using Qt since 2000. He has been an active KDE contributor for the same time and is also one of the founding members of the Qt community site QtCentre.

Both speakers have given several talks at KDE’s annual conference Akademy and other Free Software events and regularily present Qt related technical material in their capacity as Qt trainers at KDAB

Presentation

Speeding up your Qt app with new QtNetwork features

Presenter: Peter Hartmann – BlackBerry

Short Abstract:
Are you writing a Qt application that uses the network? Are you e.g. using data from Facebook, Twitter or Instagram? Then this presentation might help you getting data from the Web faster.

QtNetwork gained some new features in 5.1 and 5.2 that improve performance quite a bit. However, most of this new API will not be used unless the app developer enables it explicitly in his app. Some of these features include:

  • API for making DNS lookup, TCP handshake, or SSL handshake before sending the actual HTTP request
  • SSL session resumption
  • persisting TLS client sessions locally and reusing them

This talk will show you example on how to use these new features, as well as give some general practice on how to use QtNetwork in your application.

Abstract:
Usually, performance improvements on the network layer outperform improvements in e.g. the file system by around one order of magnitude. Often network speedups are in the range of hundreds of milliseconds, which is very hard or even impossible to achieve in any other layer of the Qt framework. Improving network latency will often create a speedup that is immediately visible.

QtNetwork gained some new features in 5.1 and 5.2 that improve performance quite a bit. However, most of this new API will not be used unless the app developer enables it explicitly in his app. Some of these features include:

  • API for making DNS lookup, TCP handshake, or SSL handshake before sending the actual HTTP request: If an app always needs to connect to the same server at startup, it could open the socket first thing when starting up (and if needed also do the SSL handshake), and then once all credentials for the HTTP request are ready, send it on the open socket; this can save several network round trips.
  • SSL session resumption: If Qt has already made a SSL handshake to a server, it automatically re-uses SSL sessions upon connecting other sockets, saving one network round trip.
  • persisting TLS client sessions locally and reusing them: Even though SSL sessions are resumed on the second socket connected to a server, it still needs to make a full handshake on the first socket. However, the server often sends a TLS session ticket, which can be persisted locally (e.g. to disk or to a database) and then re-used on the first socket when connecting, saving one network round trip.

This talk will show you example on how to use these new features, as well as give some general practice on how to use QtNetwork in your application.

Presenter Biography:
Peter is a software developer at BlackBerry, and has worked on Qt for the last 5 years, focusing mainly on networking areas (HTTP, SSL etc.) and other core areas like XML. He used to be the maintainer of the QtNetwork module, and has presented networking topics at the past 3 DevDays events.

Peter has previously worked for Trolltech and Nokia, and then joined BlackBerry one year ago, and helped porting Qt to the QNX and BlackBerry platforms.

At BlackBerry, he is busy keeping QtNetwork in shape, which is the network stack for all Cascades-based apps like Facebook, Twitter, LinkedIn, Foursquare etc.

Presentation

Qt Creator Plugin Development

Presenter: Tobias Hunger – Digia Germany GmbH

Short Abstract:
This session is for developers who want to write their own plugins for Qt Creator.

The session will cover a short introduction to the plugin architecture built into Qt Creator and then proceed to key areas for developing a new plugin.

Abstract:
This session is for developers who want to write their own Qt Creator plugin. First we will cover the Qt Creator plugin architecture with the IPlugin interface and the object pool as well as core interfaces provided by the Core plugin.

Once the basics are laid, we will discuss the implementation of an existing plugin to Qt Creator.

This presentation is targeting towards developers who want to write their own Qt Creator plugins. Having some prior exposure to Qt Creator code is recommended but not mandatory.

Presenter Biography
Tobias Hunger is a german computer geek with a degree in Technoinformatik (computer engineering) from the university of Kaiserslautern, Germany.

Tobias is a long time contributor to open source projects such as KDE. He is using Qt in a professional setting since 2006 and became part of the Qt Creator team in Berlin when he joined Nokia in 2009. He works for Digia Germany since September this 2012.

Tobias has implemented core features of Qt Creator like Target support and now Kits and is maintainer of the version control systems plugins of the IDE.

Presentation

KDE Frameworks 5: Qt add-ons overview and tier 1 case studies

Presenters: Davud Faure – KDAB, Mirko Boehm – Endocode AG

Short Abstract:
Qt and KDE are moving even closer together with the development of KDE Frameworks 5, a collection of stand-alone add-ons to Qt. With a first tech preview scheduled for December 2013, KDE Frameworks 5 are of increasing relevance for Qt application developers. The frameworks provide functionality that is just beyond the scope of Qt, but useful for many real life applications. Examples are ZIP/TAR support, hardware detection and network transparent I/O. The presentation will start with a brief overview of the philosophy of the frameworks, their history in KDE and the functionality provided by them. It will then continue with technical introductions and demonstrations of two tier 1 frameworks – modules that have no other dependencies than Qt itself, and can be added to Qt applications directly. The frameworks presented by their main authors will be KArchive and ThreadWeaver.

Abstract:
“Qt and KDE are moving even closer together with the development of KDE Frameworks 5, a collection of stand-alone add-ons to Qt. With a first tech preview scheduled for December 2013, KDE Frameworks 5 are of increasing relevance for Qt application developers. The frameworks provide functionality that is just beyond the scope of Qt, but useful for many real life applications. Examples are ZIP/TAR support, hardware detection and network transparent I/O. The presentation will start with a brief overview of the philosophy of the frameworks, their history in KDE and the functionality provided by them. It will then continue with technical introductions and demonstrations of two tier 1 frameworks – modules that have no other dependencies than Qt itself, and can be added to Qt applications directly. The frameworks presented by their main authors will be KArchive and ThreadWeaver.

In particular, the presentation will elaborate on how KDE frameworks can be added to Qt applications. This includes discussing the tiers of the frameworks provided and how they relate to dependencies that are pulled into application projects. The frameworks are available under the LGPL license. Since this particular license is commonly misunderstood, its implications will (very) briefly be explained. The session will conclude with a technical overview and hands-on demos of KArchive and ThreadWeaver. The presentation will be suitable for Qt software engineers of all levels, and for decision makers looking to incorporate the functionality of KDE Frameworks 5 into their applications. There will be time for questions. Code will be shown!

Presenter Biographies:
Mirko Boehm is a FLOSS advocate, primarily as a speaker and author. He has been a KDE contributor since 1997, including several years on the KDE e.V. board. He is a member of the FSFE Germany team and a Qt-certified specialist and trainer. Mirko is the CEO of Endocode, a collaborative engineering firm, and a representative of the Open Invention Network, where he recently took over responsibility for the Linux System Definition. He is doing research on Open Source at the Technical University of Berlin. Mirko has a wide range of experience as an entrepreneur, software engineer, manager, and a German Air Force officer. He lives with his wife and two kids in Berlin.

KDE developer since 1998, David Faure works at KDAB since 2003, on various development projects, as a Qt trainer and consultant, and nowadays as managing director for the french subsidiary. After working on Konqueror and KOffice, he is now one of the main contributors and maintainers of the KDE 4 libraries. He architects many of the changes required for the modularization effort called KDE Frameworks 5, and since Qt adopted an Open Governance model, he contributes regularly to Qt 5, particular in QtCore.

Presentation

Take Your Apps on the Road — an Automotive “101” for Developers

Presenter: Linda Campbell – QNX Software Systems

Short Abstract:
BlackBerry’s subsidiary, QNX Software Systems, is a leading provider of software platforms for the automotive infotainment market. This market segment, like many others, is being transformed by the advent of wireless cellular technology. The connected car represents a new opportunity for the entire mobile ecosystem, as it evolves into a platform for the consumption of content, apps, and services.
The opportunity, while significant, is not without challenges. Automotive development cycles are lengthy and the resulting products — cars and their components — live for a long time in the market, especially compared to other consumer goods. The market is highly competitive and it faces public scrutiny on the issue of driver distraction. On the bright side, automakers see technology, including app-capable infotainment systems, as key to differentiating their vehicles.

For the uninitiated app developer, tackling automotive can be daunting. In this session, we provide an overview of the automotive ecosystem, the current state of apps in the car, the challenges developers face, and a view of what the future holds. We aim to answer the questions that developers have about entering this market — and how they might make money doing so.

Abstract:
BlackBerry’s subsidiary, QNX Software Systems, is a leading provider of software platforms for the automotive infotainment market. This market segment, like many others, is being transformed by the advent of wireless cellular technology. The connected car represents a new opportunity for the entire mobile ecosystem, as it evolves into a platform for the consumption of content, apps, and services.

The opportunity, while significant, is not without challenges. Automotive development cycles are lengthy and the resulting products — cars and their components — live for a long time in the market, especially compared to other consumer goods. The market is highly competitive and it faces public scrutiny on the issue of driver distraction. On the bright side, automakers see technology, including app-capable infotainment systems, as key to differentiating their vehicles.

For the uninitiated app developer, tackling automotive can be daunting. In this session, we provide an overview of the automotive ecosystem, the current state of apps in the car, the challenges developers face, and a view of what the future holds. We aim to answer the questions that developers have about entering this market — and how they might make money doing so.

Presenter Biography:
As director of ecosystem evangelism for QNX Software Systems, Linda Campbell is charged with driving recognition for QNX CAR, the leading automotive infotainment platform, among key mobile industry stakeholders, including carriers and developers.

In her previous role of leading the alliance practice at QNX, Ms Campbell was a key contributor to the company’s business strategy. Over the years, she has been prime on developing relationships with Apple, Adobe, Alcatel-Lucent, Audi, Freescale, Gracenote, Google, IBM, Intel, NVIDIA, Texas Instruments, and many other industry players. Her team built a technology ecosystem that encompasses hundreds of hardware, software, and service vendors worldwide.

Ms Campbell has also spearheaded QNX participation in industry initiatives such as the Connected Vehicle Trade Association, Eclipse, and ng Connect. Recently, she helped develop the M2M alliance strategy for QNX Software Systems and BlackBerry.

Ms. Campbell holds a Bachelor’s of Commerce from the University of Ottawa.

Presentation

QtQuick and Input Events (Touch, Mouse, Keyboard)

Presenter: Frederik Gladhorn – Digia

Short Abstract:
An in depth view on how touch and mouse input handling works in Qt Quick 2. Qt Quick 2 provides several components to handle input, but so far there are several tricky issues when combining them.

In this talk you will get an overview of how the event comming from the platform ends up at you Qt Quick Item.

With this background it will be clear how to get the best out of MouseArea, Flickable, MultiPointTouchArea and PinchArea when it comes to being “”touched””.

Abstract:

Usually handling input events in Qt Quick just works. But there are some tricky situations when combinging the different event handling items. Imagine a photo viewer, a Flickable to scroll the image, a PinchArea to zoom and a MouseArea to handle double-tapping to zoom back to the initial size. How does Qt Quick process events, when and how are they propagated and when does the combination of these elements stop working together? What needs to be taken into account when writing a custom item handling input from mouse or touch devices? In this talk we’ll look at input events in Qt Quick.

Another interesting area is keyboard handling and we’ll take a short look at how it works as well, taking the concept of focus and active focus into consideration, since these topics can be a real headache to the unsuspecting developer.

Presenter Biography:
Frederik Gladhorn is working at Digia on Qt. Amongst other things he focuses on making Qt accessibility a top-notch offering. He’s been part of the Qt and KDE community for many years.

Presentation

Signals and Slots in Qt 5

Presenter: Olivier Goffart – Woboq

Short Abstract:
Signals and Slot is one of the Qt’s key concept. Qt 5 introduce a new connection syntax, which allows compile time checking, smart type conversion, connection to lambdas, and more. In this talk, we will compare the old and the new syntax, see how to use it and what is possible, including tips and pitfalls. We will also go a bit under the hood and look a bit of the implementations of signals and slots which should help you to understand them even better.

Abstract:
One of Qt’s main particularity are the signals and slots. They enabled from the beginning making easy user interface and are probably a key to Qt’s success. They still play a big role in QML. Qt5 which was just released less than a year ago, introduces a new syntax for connecting your signals and slot. Instead of using the SIGNAL and SLOT macro, you can use pointer to member functions. This has numerous advantages such as compile time checking of the validity of the connection, and automatic conversion of types regardless of typedefs or namespaces, or to be able to connect to lambda expressions. This talk will introduce this new syntax in details, with examples of what you can do and common mistakes to avoid. We will also go over some implementation detail and design decision behind it. It is much easier to understand and use efficiently.

Presenter Biography:
Olivier Goffart started working with Qt 10 years ago with his involvement in KDE. He was then hired by Trolltech to work on Qt in 2007. He has been working on various areas of Qt including the itemview framework, the widget stylesheets, QtScript, the QObject internals, and the QML debugger for Creator. He is now the co-founder of Woboq, a company based in Berlin focussing on Qt.

Presentation

Adaptable UIs with QtQuick

Presenter: Alan Alpert – BlackBerry

Short Abstract:
Modern mobile UIs have both high standards and diverse platforms. Naturally your application logic runs the same everywhere thanks to Qt, but for a pixel-perfect UI you may have to re-write the UI per device. Especially with devices starting to differentiate even within a single platform, such as the different form factors of the Z10 and Q10 BlackBerry devices.

QtQuick is here to help, with expanded features in Qt 5.2 to minimize UI rewriting without compromising the expressive power and fine-grained control of QtQuick. Use bindings, loaders and file selectors to tweak your UI per device (or per platform) to allow pixel perfect design and extensive code sharing. While Z10 and Q10 are used as the examples, these are generic QtQuick techniques that apply just as well to conquering Android fragmentation as well as UIs crossing the desktop/mobile boundary.

Abstract:
Modern mobile UIs have both high standards and diverse platforms. Naturally your application logic runs the same everywhere thanks to Qt, but for a pixel-perfect UI you may have to re-write the UI per device. Especially with devices starting to differentiate even within a single platform, such as the different form factors of the Z10 and Q10 BlackBerry devices.

QtQuick is here to help, with expanded features in Qt 5.2 to minimize UI rewriting without compromising the expressive power and fine-grained control of QtQuick. Use bindings, loaders and file selectors to tweak your UI per device (or per platform) to allow pixel perfect design and extensive code sharing. While Z10 and Q10 are used as the examples, these are generic QtQuick techniques that apply just as well to conquering Android fragmentation as well as UIs crossing the desktop/mobile boundaries.

This is very similar to the adaptive web design craze that’s currently going around. However QtQuick provides a more coherent and holistic story which allows for finer-grained control built in. This presentation will cover the following adaptive mechanisms and how they fit together.

File selection, new in Qt 5.2, allows for easily integrated code reuse. Similar in effect to managing different QRC files per device, file selection can be controlled at runtime and is easier to manage and integrate into your workflow. Combined with the new singleton QML types they also provide an easy and efficient mechanism for centrally storing and swapping per-context settings.

Bindings, the core of QML, allow for easily adpative UIs. Combined with the QtQuick.Layouts (new in 5.1) it’s easy to write UIs that adapt to window or screen resizing. You can bind to screen size or DPI in order to smoothly adapt to a continuous range of DPIs, or use JS snippets to define your own buckets for fixed adapatations.

Loaders can bring bindings and file selection together for extreme customization cases. You can swap out parts of UI scenes at any time in a declarative fashion.

By combining these approaches intelligently, code duplication is minimized without compromising the high graphical standards for your UI. You still have full control and can reach pixel-perfect standards for each device, without needing to write and maintain multiple copies of the application UI.

Presenter Biography:
Alan has been developing Qt since he was a Trolltech employee, and was a member of the original Brisbane team which developed QML. His mission, continuing in Blackberry, is to support the creation of modern and pixel-perfect mobile UIs using Qt and QML. He is currently the QtQuick maintainer and spends most of his time developing further QML and QtQuick features.

Presentation

Introducing QtWebEngine

Presenter: Pierre Rossi – Digia Norway

Short Abstract:
QtWebEngine is a new project that focuses on integrating web content into Qt applications. While it is currently still in the prototyping phase, we are confident that it is here to stay in the longer run. Using the Chromium code base allows us to use the rich set of features that Chromium offers with very little additional implementation effort and to quickly adopt the new features that are constantly added.

This talk will give some insight into the current state of the project, what we are trying to achieve with it and how we approach these goals. Moreover, we will talk about our plans for the future, the challenges we are currently facing, and we will highlight some transitioning scenarios we envision for QtWebKit users.

Abstract:
QtWebEngine is the result of recent experiments looking at other ways to offer web content integration into Qt applications. Currently, the project is in the prototyping phase as a Qt Labs project. Since we are confident that this is a step in the right direction, we recently opened QtWebEngine up for contributions through Gerrit code review.

QtWebEngine uses Chromium’s rendering engine to render web content. This engine is also known as “”Blink”” and was forked from the WebKit codebase in April 2013. So albeit it is a relatively young project of its own, it already offers a reliable and high quality engine for rendering web content. An additional benefit is that it is available, tested and maintained on all major platforms and developed with cross-platform support as a primary focus.

The approach for integrating Chromium and Qt differs significantly from the one taken when integrating WebKit; while QtWebKit is essentially a full WebKit port that needs to take care of the the entire platform integration, the integration with the Chromium engine typically happens at a different level and uses common code for e.g. rendering, network access and file management. With QtWebEngine, we are taking the approach to share as much code as possible and only provide a thin integration layer as well as a Qt Widgets and QML API. This way, we are trying to achieve the integration at relatively low maintenance efforts while using the benefits of a feature rich and high quality rendering engine.

This talk will give a deeper insight into our motivation for creating this project, what we intend to achieve with it and how we want to reach these goals. We will give an overview of the general building blocks of the integration and highlight the key differences to the integration of QtWebKit.

Furthermore, we will demonstrate the current state of the project, show example use-cases and provide scenarios for migrating applications to QtWebEngine. Last but not least, we will talk about the current roadmap for the project and discuss challenges and opportunities on the road ahead.

Presenter Biography:
Pierre Rossi is a software engineer at Digia. He studied at ISAE in Toulouse before joining Nokia in 2009. After a 2 year gig with Qt support, he joined the QtWebKit team in 2011. Outside of the office, he enjoys climbing Norwegian ice in the winter and eating it in the summer when it gets hot (yes, that’s possible).

GitHub link

Natural task scheduling using futures and continuations

Presenter: Ivan Čukić – KDE; Faculty of Mathematics, University of Belgrade

Short Abstract:

We are used to think about algorithms in a procedural manner – with loops, branches and subroutines. Presenting an algorithm as an easily understandable flow between its steps.

In the real world, where we need to reduce latency and forbid the blocking API calls, these flows get broken. Due to the inversion of control (IoC) required by the introduction of asynchronous APIs (Xlib vs. XCB, iostream vs. boost::asio), the code becomes an unreadable call-callback soup.

We are presenting a way of defining the algorithm flow in a procedural manner and leaving it up to the C++ compiler to generate the necessary asynchronous code.

Abstract:
We will show how to leverage the Qt features like QFuture to implement the continuation monad. It is one of the rarely used, but immensely powerful concepts for defining a pure way of creating program control structures.

With the continuators and continuations, we are able to mimic all control structures provided by the language like serial execution, different loop types, branching and similar, along with some that are not available such as the parallel execution that can wait for all subtasks to end (all_of), for only one (any_of), or just detach the tasks and ignore whether they have finished or not; transactional execution which undos all the steps in reverse if some of th

em failed and similar. We can even pull some idioms from other programming languages like do or die(“”error message””) in Perl and PHP.

By converting any type of asynchronous (threads, fibers, event-loop-based, GPU calculations etc.) or synchronous execution to a continuation, we get a very powerful abstraction that allows us to treat them all the same. And all that without any performance penalties thanks to the template unwrapping, inlining and other optimizations done by the compiler.

This approach eases the development in many cases such as implementing the networking clients or servers where we are not allowed to block the program execution between sending a request and receiving a response; programs that use a limited thread pool or thread-reusing with the producer-consumer design pattern; programs that need to invoke an external process and handle its output data in chunks or as a whole; programs that have more complex user (UI) flows and similar.

Instead of having a bunch of methods that are not logical subroutines of the program, we get a program that is a nicely written set of tasks that are logically inter-connected. We get a program that is easy to write, and even easier to read and reason about – a program that looks as simple as if it was written for a blocking API.

The work is heavily based on some of the new C++11 features like variadic templates and lambdas, while also demonstrating some older lesser-known template meta-programming idioms like static introspection with SFINAE.”

Presenter Biography:
I am a doctoral candidate (PhDc) at the Computer Science department of the Faculty of Mathematics, University of Belgrade with main research revolving on the programming language design and deductive databases. Working at the faculty as a teaching assistant for C++/Qt and OpenGL courses.

Have been a long time KDE contributor mainly working on the Plasma workspace, and lower-level semantic-enabled frameworks for tracking and predicting the user actions. Maintainer of KActivities, Contour daemon and Lancelot.

Lately, a vocal evangelist regarding the use of the new C++11 features, as well as older seldomly known C++ idioms, for cleaner and safer development practices throughout the KDE community.

Presentation

QtConnectivity in Qt5

Presenter: Presenter: Alex Blasche – Digia, Fabian Bumberger – BlackBerry

Short Abstract:
Qt 5.2 adds two new Qt Add-ons in the area of connectivity. The talk will introduce into developing Bluetooth and NFC applications on Desktop and mobile devices. It features device interaction using the various capabilities presented by the two APIs. The examples will feature C++ and QML aspects. Furthermore it will update on upcoming features relevant those APIs. This may include Bluetooth Low Energy support and smart poster support in NFC.

Abstract:
Starting with Qt 5.2 the Qt Bluetooth and Qt Nfc APIs will become new add-on modules for Qt. They open up new opportunities for Qt developers who want to develop use cases within these mobile domains and provide a supported alternative for those developers who have been forced to use the deprecated Qt Mobility API’s so far. The presentation details the features supported by the various platforms and outlines strategies on how to implement applications that can cope with possible platform differences.

The Qt Bluetooth API enables the user to manage the local Bluetooth device and discover surrounding devices for the purpose of device interaction. This includes service discovery and the establishment of various types of connections. The presentation will walk through the development of a Bluetooth application that connects to a remote device (e.g. BB or Android) and provides hints on how to overcome some obstacles that might be encountered during the process.

The second part of the presentation will present an NFC application that interacts with NFC tags presenting some of the opportunities opened up by this technology. It introduces the concepts of different NFC tags and demonstrates how NFC development kits can be used during the development and testing phase of applications.

The presentation closes with a sneak preview into some of the upcoming connectivity features. The exact list is somewhat unknown at this stage as it is subject to road map decisions but it may include Bluetooth Low Energy, extended NFC tag support and ports to new platforms such as iOS and Android. The precise feature set will be updated closer to the presentation time.

Presenter Biography:
Alex Blasche has been part of the Qt development team for the last ten years. When he joined Trolltech, he started as embedded software developer using Qt 2.3. Later he contributed to Qtopia/Qt Extended and in 2008 became technical lead for the design and development of the Qt Mobility APIs. In particular he worked on QtLocation, QtServiceFramework and build system related Mobility tasks. Following the announcement of Qt 5 he continued the Mobility effort by porting the API’s to Qt 5 and is the maintainer for some of them. Currently he works on Qt Connectivity and Qt Location and acts as liaison for some of the other Mobility APIs.

Fabian Bumberger fell in love with Qt during his studies at the TUM while controlling robots.
He worked with Qt in Nokia’s Developer Experience and Marketing group and afterwards in 2012 joined BlackBerry’s Qt team in Munich. He currently works on the BlackBerry10 Qt port, in particular QtConnectivity.

Presentation

State and future of QtWebKit

Presenter: Allan Sandfeld Jensen – Digia

Short Abstract:
The WebKit project has changed greatly in the last year, QtWebKit is still an active member of the project, but we will have to adjust our ambitions and goals moving forward.

This talk will highlight new features of QtWebKit in Qt5, what is to be expected in Qt 5.2, and what the role QtWebKit can play if the Qt project choose to focus more on the Chromium-based QtWebEngine, and how we can maintain QtWebKit in the future.

Abstract:
Since last year we have released Qt 5.0 and 5.1 with new versions of QtWebKit. In the WebKit project Apple changed their contribution model for the WebKit2 layer, and the project was halved with the exit of Google and the creation of Blink.

Part of the QtWebKit team has started the project QtWebEngine to explore the option of providing a Chromium/Blink based web engine instead of QtWebKit, and in addition to that, the iOS port of Qt will need their own webview API since Apple does not allow additional web engines on their iOS devices.

All these events mean that the QtWebKit project will have to change, but it does not mean the project will fully disappear or that it is dead.

This talk will discuss where the QtWebKit project is heading. How we can ensure existing users of QtWebKit will not be left behind, and we can continue to provide the features they need.

I will talk about the features that will be hard or impossible to provide in QtWebEngine, such as the deep integration with Qt we have in the QWidget (WebKit1) API, and QtWebKit’s current advantages on embedded systems.

Finally I will talk about features we can not provide in QtWebKit, and where we will have to recommend existing users to try out QtWebEngine if they need them.

Presenter Biography:
Allan is a senior software developer at Digia. He studied Computer Science at Copenhagen University, has been a contributor to KDE since 2001 and is a former maintainer of KHTML. Since joining Nokia in 2011 he has been working in the QtWebKit team.

Presentation

QmlWeb – Running QtQuick Applications on the Web

Presenter: Anton Kreuzkamp – KDE and Thomas McGuire – KDAB

Short Abstract:
QML is the language that makes writing application UIs easier than ever before. QmlWeb now brings this ease to the web.

While the demand has risen to use web technologies on the desktop, QmlWeb takes the opposite approach: The JavaScript library understands QML and renders QtQuick based applications to a website using the webbrowser’s Document Object Model and CSS. In other words, QmlWeb enables to use modern desktop technologies on the web. Using e.g. QML’s property bindings and QtQuick’s anchor layouts allows you to do tasks like complex positioning and animations with just a single line of code.

This talk will provide an overview of what QmlWeb is, how it works, what its advantages and where its limits are. It will show how you can reuse knowledge from desktop development for web applications.

Abstract:

QML is the language that makes writing Qt application UIs easier than ever before. QmlWeb now brings this ease to the web.

Traditionally desktop applications were written in languages like C or C++. Web technologies like HTML and PHP were mainly used to write static websites. With the rise of modern web applications and technologies like HTML 5, CSS 3 and ECMAScript 5, those technologies became more and more popular. But technological development on the desktop side continued as well. Modern technologies like QML + QtQuick allow us to write complex user interfaces easier than ever before in a declarative manner.

For companies the separation between desktop and web technologies means that they have to maintain two seperated groups of developers, one for doing desktop applications, and one for web development. Because of that the demand has risen to use web technologies on the desktop and especially for mobile applications as well.

QmlWeb takes the opposite approach. The JavaScript library understands QML and is able to render a QtQuick based application to a website using the webbrowser’s Document Object Model and CSS. It is capable of property bindings, anchor-layouting and most kinds of simplifications offered by QML. Impressive animations are only a few simple lines of QML code away. States and components help to keep even complex applications well-stuctured and easy to read. Many of the little pains webdevelopers often have to struggle with are becoming just a single line of QML code.

To achieve this, QmlWeb e.g. implements a system to track dependencies between properties and automatically update dependant properties on change. Positioning, which is one of the most inconvenient things in CSS, is completely done in JavaScript and then exposed to the browser using absolute positioning in CSS.

The talk will provide an overview of what QmlWeb is, how it works internally and what its current state of development is. It will demonstrate how developers can reuse their existing knowledge from the desktop for web applications. Therefore, it will include a live demo, in which a small web application using QmlWeb will be written. The talk will show what pieces of QtQuick are supported, what is still missing and also what features QmlWeb adds to match with the web. QmlWeb will be compared to other technologies to display where its advantages and where its limits are. At the end the audience should have an idea of what QmlWeb can do and should be able to decide whether QmlWeb could be suitable for his/her next web application.

Presenter Biography:

Anton Kreuzkamp is member of the KDE community since 2010, supporting Rekonq and Plasma development, where he first got in touch with QML. Anton started to work on QmlWeb during the last year within the context of his graduation from secondary school in 2013. By now, he is the main developer of QmlWeb.

Asynchronous programming (and more) with Qt5 and C++11

Presenter: Dario Freddi – Ispirata

Short Abstract:
C++11 and Qt5 are a match made in heaven when it comes to increasing productivity and efficiency in daily development tasks. Many problems which used to require intricate and ugly solutions can now be solved with elegant approaches leveraging new features to be found in the new C++ standard and Qt’s latest major release.

This talk will run through best practices we can now take advantage of when dealing with complex code paths, especially when being asynchronous is a strict requirement: from handling unix signal to initialization chains, we’ll find out how to make our code more readable and efficient.

Abstract:
New C++ and Qt features, lambdas and Qt’s new connect syntax above all, allow for a more efficient and elegant refactoring of many common code paths. Especially when dealing with asynchronous programming, it was common to have a multitude of slots to cope with the various operation to be performed, with the added effect of scattering the code around, and exposing symbols which would likely be private instead – Q_PRIVATE_SLOT used to be a popular alternative to this.

Of course, there’s many other cases where this reasoning applies: creating wrapper classes for applications to be able to do asynchronous processing which should happen in the main function is still a common practice, which can now be avoided. Pending objects such as QDBusPendingCallWatcher might finish processing before connecting to a slot.

These situations and more will be showcased extensively, proposing several alternate solutions using Qt5 and C++11. It will be shown how the use of those practices results in a discrete amount of lines of code saved and a more readable code.

Presenter Biography:
Dario Freddi found his love for Qt by being strongly involved in several open source projects since his early years – in particular KDE, to which he started contributing in 2007, and never stopped. From there on, he signed up as a Qt Ambassador and specialized in freedesktop.org technologies integration, writing Qt bindings to several open source frameworks such as polkit and Telepathy.

He is a regular speaker to some of the most important Open Source conferences worldwide, usually on Qt-related topics.

Qt has been an integral part of his academic and work life since forever – his degree in Information Engineering came with a thesis over an abstract communication system for musical devices completely built on top of Qt. Afterwards, he worked as a freelance consultant for several important companies around the globe, and nowadays he runs Ispirata, a company providing services and products built around KDE and Qt technologies.

Presentation

Qt on WinRT

Presenter: Andrew Knight – Digia

Short Abstract:
Apart from a new touch-oriented experience, Microsoft’s latest family of Windows operating systems also brings a new API: Windows Runtime (WinRT). The WinRT port for Qt takes advantage of this new set of interfaces, bringing Qt to an ecosystem spanning PC, tablet, and smartphone boundaries. Besides showing the new Qt port in action (and helping you get started with it), we’ll discuss how the new platform has been integrated into QPA, how the developer experience differs from other Qt platforms, review the current Qt Creator integration, and examine how will ready the port for Qt 5.2. Attend this session to view the current progress and future direction of this exciting new Qt platform.

Abstract:
If you’re confused about all the different terminology surrounding Windows 8, RT, Metro/Modern UI, and Windows Phone 8 – and how Qt fits in – this presentation is for you. Consisting of a range of technical topics in platform integration, there should be something for all developers interested in Qt on Windows platforms.

Qt Platform Abstraction (QPA) has made it easier than ever to integrate new platforms into Qt. Windows Runtime, the new API for the Windows 8 family of operating systems, is ready for the challenge. Since developer days last year, the development of WinRT as a Qt platform has made slow yet steady progress; it is now approaching a usable state on Windows 8 and Windows Phone 8, making it a viable option for technical preview status in Qt 5.2.

This presentation covers:

  • Overview of the port’s status
  • Basics about the WinRT API and how it fits in with the existing source code and tooling
  • Selected examples of WinRT API integration with QPA
  • A selection of continuing challenges, such as networking and scene graph integration
  • Use and features of Qt Creator WinRT plugin
  • Vision for Qt on WinRT for Qt 5.2 and beyond
  • How you can get involved

Presenter Biography:
Andrew Knight is a consultant with Digia, where he has worked as a user interface software engineer since the early days of Qt at Nokia. He transitioned to the Qt organization after the acquisition of the Qt Commercial business, and now spends his days helping clients with Qt-based solutions. Having a web developer background, Andrew’s has enjoyed creating Qt Quick interfaces for customers since Qt 4.7. He is enthusiastic about platform adaptation, and currently spends much of his time with his head buried in QtWayland source code. You might also notice his commits to code review in the late hours of the evening as he tries to get Qt on WinRT off the ground.

Andrew is an emigrant to Tampere, Finland, where he lives with his wife amid the natural Nordic scenery.

Step by step Qt on Android tutorial

Presenter: Bogdan Vatra

Short Abstract:
This step by step tutorial is an introduction on how to setup and use Qt Creator to create, deploy, debug sign and publish Qt apps for Android.

Abstract:

The tutorial will start with instructions on how to setup the development environment, how to configure QtCreator and ensuring that all dependencies are met.

It will then continue with a live demonstration on creating an app, deploying it to an Android device and debugging it there.

Once the app runs satisfactorily, the demo will continue by showing how to publish it to the Google Play store, including necessary steps such as signing the package.

The rest of the presentation’s time slot will be used to introduce the audience to the inner workings of Qt on Android, explaining how it works together with the platform’s Java stack and how to further extend platform integration for application specific needs.

Presenter Biography:
Bogdan has been using Qt since 2002 and is the author of Qt for Android port. He is an active KDE (Necessitas) and qt-project contributor.

Presentation

Fast QML UI prototyping for platforms WITHOUT Qt/QtQuick support

Presenter: Attila Csipa – Nokia

Short Abstract:
Every now and then we come across a platform that does not support Qt, or whose list of Qt modules does not include QtQuick(2), is lacking in performance, or which simply lacks a component-set that provides a native look-and-feel. This session will show how to use QtCreator, QML and the QtQml module with custom code-generating components to create a workflow for fast UI prototyping, without the need for Qt or QtQuick on the target platform. In practical terms, QML as a language is used to template and generate UI code. Two real-life examples will be presented to validate and show the benefits of the approach, a Java ME QML component set (used to prototype user interfaces for applications running on Nokia Asha devices), and a text component set (used on headless embedded/system applications using Qt). Finally, options to use the approach to prototype a native declarative UI for Windows Phone (XAML) and Android (XML) are explored.

Abstract:
Qt as an application framework has an ever-expanding list of supported platforms, and has a UX development workflow which has been widely acclaimed for the speed and efficiency in development. However, there are platforms on which developing a QtQuick or even QWidgets application is simply not a feasible option at this moment – whether due to the lack of Qt official support, missing required modules, dsitributable size limits, specific performance issues or simply lack of a component-set that provides a user experience in line with the native application offering on that platform. This session will approach this problem from an UX prototyping perspective, where QtCreator and QML are used with custom code-generating component sets that are able to provide a fast and natural UI development process for existing Qt developers. The output of these components is not necessarily an end-user usable UI – instead, we will be just using the QtQml module (not QtQuick!) module to generate platform specific code that replicates the functionality in a form that is compatible with the target platform. Two real-life examples will be presented to validate and show the benefits of the approach. The first component set is for Java ME, which allows for fast prototyping of user interfaces for Nokia Asha devices (which normally do not run Qt in any form). The second example is a text component set, which allows for the fast development for headless embedded/system console applications using Qt. Finally, options to use the approach to prototype a native declarative UI for Windows Phone (XAML) and Android (XML) are explored.

Presenter Biography:
As a passionate Open Source and Qt advocate, Attila has been developing and promoting Qt on a range of platforms. While he started on the desktop with Qt3, during the years he has moved on to develop on effectively all major Qt-supported mobile platforms. He is maintaining a number of cross-platform Qt applications and libraries (like QtInfo, and historically the community builds of PyQt and QtMobility on Maemo). Attila currently works as a Technology Wizard in Nokia’s Developer Relations team, and when he’s not touring the world providing mobile development related trainings, he’s focusing on the future of Nokia Asha smartphones.

Presentation

Minding the Gap – Going from UX design specs to successful implementation

Presenter: Dorothy Shamonsky & Andrew Babkin – ICS, Inc

Short Abstract:
The quality of a user experience is equally dependent on a quality design and a quality implementation of that design. By “quality of implementation” I don’t mean code quality, but how true the implementation is to the full intention of the UX design. As a UX designer I know all too well that a good design means nothing if the implementation of that design is marginal. Certain factors can contribute to the success or failure of translating a design spec into code, and ultimately a great user experience. Topics include: the art of spec reading (and writing), the science of collaboration, the philosophy of patterns, the theory of ownership.

Abstract:
The quality of a user experience is equally dependent on a quality design and a quality implementation of that design. By “quality of implementation”, I don’t mean code quality, but how true the implementation is to the full intention of the UX design. As a UX designer I know all too well that a good design means nothing if the implementation of that design is marginal. Certain factors can contribute to the success or failure of translating a design spec into code and ultimately a great user experience.

The Art of Spec Reading (and Writing)
Writing a complete UX spec is very time consuming and usually there is little or no time for it prior to beginning the programming on a project. Nevertheless, I have found no matter what is written it is never enough. Yet surprisingly, even small specs go largely unread. So how is it possible to create a design spec that is easy to read, effective and doesn’t take much time to create? More importantly, how do you get a developer to read it!

The Science of Collaboration
UX implementation requires more communication between developers and designers than is expected and that is not always comfortable, at least for developers. Collaboration is a fundamental part of any design practice and UX design is no exception. Generally, designers thrive on collaboration. The complexity and subtlety of most UX designs requires on-going communication between development and design. Much of what is in the design cannot be conveyed in words or still images. So not only are regular, ongoing meetings essential, but the UX designer needs the opportunity to review the implementation work regularly. Many details of a design can only be worked out in the context of the functioning UX. Deal with it, expect and accept multiple iterations! Sorry, multiple iterations really are necessary!

The Philosophy of Patterns
I am always surprised that developers don’t naturally seem to look for the patterns in a UX design. UX design is a pattern language and the patterns translate into components and reusable code. If the patterns are not considered in the implementation, consistency becomes a problem. In addition, consistency is paramount in a UX. Lack of consistency single-handedly makes a UX appear unprofessional, broken and thus, more difficult to use. Styles are also essential to maintain consistency. Pixel perfect is a useful expression, but the intention of the design is much more important!

The Theory of Ownership

The developer may own the code but the UX designer must own the UX, or how else can professional quality be maintained? This is an uncomfortable and sometimes contentious situation, because the designer does not have any actual control of the code. Seek signoff from the UX designer at every step of the implementation. If so, the benefit will be a highly professional UX!

Presenter Biographies:

Dr. Dorothy Shamonsky is a user interface/user experience [UI/UX] designer for Integrated Computer Solutions, Inc. (ICS), who possesses broad practical experience and theoretical knowledge in the field. Prior to joining ICS, she held positions at Viacom, Merrill Lynch, MOMA, M.I.T. and Harvard University. She has also held teaching positions in the Interactive Media Department at the New England Institute of Art, at the Computer Graphics Department at Pratt Institute and at the Interactive Telecommunications Department at N.Y.U. Dr. Shamonsky holds a Ph.D. and Master’s Degree from M.I.T. and a Bachelor’s Degree from the Rhode Island School of Design.

Andrew Babkin is a UI/UX graphic designer at Integrated Computer Solutions, Inc. (ICS). He began his career designing web interfaces and for the past seven years has since gained experience within a wide variety of devices and form factors, including mobile, desktop, in-vehicle infotainment and other embedded devices. He has a passion for clean, flexible and intuitive UIs. Andrew is well versed in relevant UX and design techniques and technologies and holds a Bachelor’s degree in English Philology, from Volgograd State University in Russia.

Presentation

Boot to Qt

Presenter:Andy Nichols – Digia

Short Abstract
The hardest part of Embedded development is getting started. Boot to Qt was created as an effort to make Embedded development accessible for everyone. This presentation will demonstrate how you can take your idea for an embedded device and turn it into a software running on embedded hardware in a short amount of time.

Abstract
As a developer it is quite frustrating to start an embedded project and not be able get started with your product as soon as possible. You could spend days setting up a working toolchain and acquiring the necessary libraries and drivers for your sysroot and device image. At Digia we saw this as a pain point for ourselves as well as our customers, so the Boot to Qt project was created as an effort to make Embedded development accessible for everyone.

With Boot to Qt, to get started it’s as easy as obtaining some readily available consumer embedded hardware (i.mx6, beagleboard, nexus 7) and downloading the Boot to Qt SDK. From here you can select between Embedded Linux or Android baselayer as your operating system of choice and you are a few simple instructions away from deploying your application directly from the QtCreator IDE.

This presentation will demonstrate how you can take your idea for an embedded device and turn it into a software running on embedded hardware in a short amount of time.

Bio:
Andy Nichols is currently a software engineer at Digia in Olso, Norway. He has worked with Qt for the last 7 years. Andy was a Qt support engineer at Nokia for 3 years who focused on customers using Qt for embedded Linux. He later took a role as a software engineer at Nokia with the Qt graphics team where he worked on the Qt Platform Abstraction (QPA) in Qt 5 as well as the QtWayland module. Since joining Digia he has been focused on Wayland, Multimedia, and the Embedded Linux and iOS ports. Andy is the maintainer of the QtWayland module.

GitHub

Qt for iOS

Presenter:Richard Moe Gustavsen – Master in Informatics, UiO

Short Abstract
With Qt 5.2, Qt will ship with support for iOS. This talk will give a presentation on what you need to know when creating Qt applications for iOS. A QML application will be written from scratch that uses some of the new APIs in Qt for working with mobile applications, together with a demonstration on how you can mix in usage of native iOS APIs.

Presenter Biography:
Richard Moe Gustavsen: Master in Informatics, UiO. He worked several years as a research scientist for the Norwegian Defence before starting to work with Qt in 2006. Aside from iOS, he has worked primarily on Qt/OS X and Qt Quick Controls.

GitHub

Testing of embedded and mobile Qt and QML Applications

Presenters: Reginald Stadlbauer and Harri Porten

Abstract:

The benefits of automated tests in general, such as the ability to run more tests in less time, also apply to GUI tests. But automating GUI tests for Qt and QML user interfaces in a cross-platform environment, esp. on embedded and mobile devices, comes with its own set of challenges.

In this talk the presenter will discuss the challenges of automated Qt and QML GUI tests on mobile devices, such as iOS and Android and embedded / RTOS systems, such as QNX, VxWorks, embedded Linux and Windows CE.

The presenter will cover topics including distributed test setups, remote test authoring and debugging and testing in simulated/emulated environments vs. real devices. To showcase the discussed approaches in practice, the talk will be concluded with a short live demonstration.

Presenter biographies:

Reginald Stadlbauer
Reginald co-founded froglogic, the creator of the Squish GUI testing tool with special support for automating Qt GUI tests after having worked as Senior Software Engineer at Trolltech, the original makers of Qt.

Today Reginald is involved in all aspects of the Squish product as co-CEO of the company.

Harri Porten
Harri is co-founder and co-CEO of froglogic GmbH, a company that has specialized on automated testing tools for Qt programmers. After learning about Qt through his involvement with the Open Source KDE Desktop project Harri was working as a Senior Software Engineer at the Trolltech, the original makers of Qt in Oslo.

Presentation

Qt Insights – synopsis by Kevin Franklin

Presenter: Kevin Franklin, Qt Insights

Abstract:
Launched in May 2013, Qt Insights aims to provide a thorough understanding of the Qt community by gathering evidence, conducting analysis and engaging in conversation with developers. The 2013 Global Qt Insights Report describes the key conclusions of the Qt Insights project, including top-line results of a survey of almost 2,000 Qt developers.

In this brief keynote, Kevin will present a synopsis of Qt Insights project, its findings, and possibilities for future phases of the project. Qt Insights is managed by Quadriga Consulting and is sponsored by leading organisations from across the Qt developer ecosystem.

Presenter Biography:
Kevin Franklin is Project Leader of Qt Insights (and Associate Director, Quadriga Consulting). Kevin has worked within the Qt developer community for several years having led the Qt partnering and training activities at Nokia. His team supported growth and enablement of the developer community indirectly via the global network of Qt Partners and directly by providing online learning materials and documentation. Kevin has 25 years’ experience spanning telecoms, software platforms, and mobile technologies from several business and product development roles including Symbian, Avaya, Psion and 3Com. He has a Master’s Degree in Electronics Engineering from the University of Manchester, and is currently based in London.

 

Starter Edition

Bringing Interactive 3D Visualization to Finance using Qt and OpenGL

Presenter: Jim Albamont – Aqumin, LLC

Abstract:
Aqumin is a startup company dedicated to bringing powerful interactive visualization to the financial industry. Using the power of modern GPUs, it is now possible to visualize enormous datasets that previously required expensive, specialized hardware. Aqumin’s AlphaVision software creates interactive “landscapes” of large financial data sets consisting of hundred- of- thousands to millions of unique data points that are able to run on common desktop or laptop computers. Example applications include real-time market data, historical time series, marketplace surveillance, volatility for entire options chains, real-time risk monitoring, and much more. Aqumin has also developed a Microsoft Excel Addin using the ActiveQt module to display both financial and non-financial data sets that are too large for normal 2D techniques.

This presentation will begin with a discussion of Aqumin’s software, including demonstration of several use cases mentioned above. This will be followed by a discussion of our extensive use of Qt to build the product, including Qt’s GUI, Core, OpenGL, Networking, ActiveX, and Database modules.

Bio:
Jim has over 15 years’ experience designing, architecting and maintaining large software systems using C++, Qt, and OpenGL. He received his M.Sc. in Computer Science in 2001, focusing on scientific computing and data visualization. Jim worked at JT3 designing the graphics subsystem of a real-time data collection and display system, followed by 2 years with KDAB where he worked on the 3D portion of several large Qt porting projects. He joined Aqumin in 2008 as lead developer and took over the Director of Technology position in 2011.

The five faces of Qt

In this presentation we will introduce Qt, and how it fits into the big picture. The five faces of Qt are

  • Qt Quick – the predominant way of developing for Embedded devices and phones
  • Qt Widgets – used for large scale desktop applications
  • OpenGL – Qt allows a powerful OpenGL integration both in QtQuick and using Widgets
  • WebKit – This is the happy marriage between Qt and HTML5, allowing you to have part of your application written in HTML5, part written in Qt Quick, and both parts offering services to each other.
  • QtCore – There is much more to Qt than that which meets the eye. Under the hood you will find everything from low level network access, through multi-threading support to XML parsing. Ask any Qt developer to live without this rich toolbox and you will see his productivity fall drastically.

Q&A to the panel

Many questions have likely arisen during the Starter Edition. They might be technical ones, or about the direction of Qt, or how the ecosystem works, or … Here is your chance to get an answer directly from the source.

Pushing the boundaries with Qt and OpenGL

Presenter:Dr Sean Harmer, KDAB
This talk will introduce the basics of using Modern OpenGL with Qt 5 and show how to use many of the OpenGL enabler classes that Qt provides. We will look at how to:

  • configure the GPU using GLSL shader programs
  • feed large amounts of vertex data to the GPU
  • work with textures
  • perform rendering using OpenGL onto Qt windows
  • show examples of using new shader types beyond vertex and fragment shaders

We will also demonstrate a number of ways to integrate OpenGL into your Qt-based applications covering both widget and Qt Quick 2 applications. The latter is ideal for embedded devices that wish to show a Qt Quick 2 UI over the top of OpenGL rendered content.

Presenter Biography:
Dr Sean Harmer holds a Master of Science degree in Mathematics & Astrophysics and a Ph.D. in Astrophysics. Sean has been developing with C++ and Qt since 1998 and in a commercial setting since 2003. Sean has been involved in developing software in many areas including engineering, safety & risk, oil & gas, visualization and numerical simulations. Sean is currently heading up operations at KDAB UK where he is regularly involved in the development of Qt 5, the QNX/Blackberry port of Qt, OpenGL, and presenting professional Qt training courses.

Qt to help you build your developer ecosystems

Presenter: Digia
Qt has a leading position in the software development arena with over 500,000 worldwide developers and is the ideal choice for enterprise application developers, OEMs or MNOs that demand high-quality applications for their audiences. Qt’s flexible, modularized and scalable technology makes it easy for providers to develop customized Qt-based SDKs for their developer ecosystems. Learn how software powerhouses, OEMs and MNOs can take advantage of the growing number of native Qt developers in all corners of the world and provide them with the tools they need to develop millions of apps for various marketplaces and enterprise use.

Qt developer community 2013 – status and analysis

Presenter: Kevin Franklin, Qt Insights

Abstract
Launched in May 2013, Qt Insights aims to provide a thorough understanding of the Qt community by gathering evidence, conducting analysis and engaging in conversation with developers. The 2013 Global Qt Insights Report describes the key conclusions of the Qt Insights project, including top-line results of a survey of almost 2,000 Qt developers.

In this session Kevin will impart more comprehensive results, dig deeper into the conclusions of the report, and present possibilities for future research and analysis. Qt Insights is managed by Quadriga Consulting and is sponsored by leading organisations from across the Qt developer ecosystem.

Presenter Biography:
Kevin Franklin is Project Leader of Qt Insights (and Associate Director, Quadriga Consulting). Kevin has worked within the Qt developer community for several years having led the Qt partnering and training activities at Nokia. His team supported growth and enablement of the developer community indirectly via the global network of Qt Partners and directly by providing online learning materials and documentation. Kevin has 25 years’ experience spanning telecoms, software platforms, and mobile technologies from several business and product development roles including Symbian, Avaya, Psion and 3Com. He has a Master’s Degree in Electronics Engineering from the University of Manchester, and is currently based in London.

Presentation

Qt for Multi-screen development

Presenter: Tuukka Ahoniemi, Digia

Abstract:
Thanks to the extension of internet-enabled devices as well as online content and services, the environment where consumers use multiple devices to enable similar content and services seamlessly is quickly gaining ground. More and more people use an ecosystem of screens for personal and enterprise use where having the same user experience, performance and flexibility across all the devices is no longer a nice-to-have. The ability to target multiple operating systems quickly and easily to uphold the multi-device story is increasingly the key factor for developers looking to make their applications available everywhere. Besides plain code re-use it is essential to be have fluent means to customize the user experience across the device space adapting into desired screen sizes and native look-and-feel features of a platform.

This session will present how Qt can be used to create and deploy graphically-pleasing, robust and native applications across various operating systems such as Windows, embedded Linux, BlackBerry10 and Android with one source code. The talk will focus on how Qt’s productive C++ libraries, IDE and Qt Quick technology enable developers to efficiently build fluid and highly-performing applications for several target types by simply reusing code and shortening time to market.

Presenter Biography:
Tuukka works with the product marketing of Qt, Digia. For the past years he has traveled around the world spreading the message of Qt supremacy in the form of having held over 100 Qt training courses, speaking in various conferences and trade shows. Still trying to “finish” his PhD he holds a M.Sc (tech) in Computer Sciences with the background in academic teaching of programming and research around it. Still being passionate about teaching he is a certified Qt trainer, Nokia Developer Certified Trainer, Certified Qt Specialist and a Nokia Developer Champion. “A man this ugly needs something Qt in his life”, describes Tuukka and his deep feelings towards the framework. Tuukka is based in Tampere, Finland.

Integrating HTML5 into Your Qt Development

Presenter: Lars Knoll, Digia, Qt CTO & Qt Project Chief Maintainer

Abstract:
HTML5 provides a large ecosystem of developers and an easy alternative to deploy rich-media applications for all targets. Native application development using languages such as C++ delivers the best performance and an unmatched user experience as well as integration with the host operating system. This session will focus on how Qt’s C++ library provides powerful building blocks for a rich user experience and performance for native development and many hybrid development use cases. It will present how the use of Qt WebKit is ideal for current projects requiring HTML5 functionality integrated into their native desktop and embedded development. In addition, it will address the future development of the recently introduced Qt WebEngine and explain the outlook of how it will better enable web features and native development allowing products dependent on web technologies and hybrid capabilities to move quickly with market requirements.

Presenter Bio:
Lars Knoll is the Digia, Qt CTO and Qt Project, Chief Maintainer. He has been working on Qt for more than 12 years starting as a software engineer to later leading the global Qt engineering team in Nokia before the Digia acquisition in October 2012. Lars has been an active member of the KDE community and the architect behind KDE’s HTML rendering library that formed the basis for the WebKit open source project. Lars holds a PhD in physics from the University of Heidelberg. He is German national and lives with his family in Oslo.

Developing with Qt widgets for the desktop

Presenter:Andras Mantia (KDAB)

Abstract:
Qt widgets for the desktop is a very mature product that sits at the core of hundreds of thousands of applications. Examples include everything from KDE (the Linux desktop) to applications for oil and gas exploration, which literally have hundreds of dialogs for customizing the complex algorithms used.

The Qt “toolbox” for widget development consists of multiple parts:

  • comprehensive widget library for user interface elements
  • comprehensive framework for common tasks like networking, config files, multithreading, etc
  • tools for building the application cross platform
  • tools for laying out the user interface graphically
  • support for translating the application to foreign languages

Today, perhaps the best feature is that you can share a large part of your code base, either with a tablet version or another embedded version of your application.

Presenter Biography:
András has actively developed with Qt since 2002 and is a core developer of KDE’s web development environment Quanta Plus and contributor to other parts of KDE. He talks at free software events about Qt-based products and has held trainings for companies like Accenture, TietoEnator, and Nokia.

Introduction to Qt on Ubuntu

Presenter: Canonical

Abstract:
The purpose of this presentation is to inform the audience about Ubuntu Touch using Qt, its current state and roadmap. It will educate developers on how to write their first app on Ubuntu Touch using Qt and QML, showing off the design patterns and APIs provided by the Ubuntu Touch developer offering. Finally it will provide a walkthrough/tutorial on how to port existing Qt/QML applications to Ubuntu Touch.

After attending this session the audience should have a good insight on what is required to get running on Ubuntu Touch and how to write applications in a way that they adapt to the range of devices and form factors supported by Ubuntu Touch.

Targeting Embedded Platforms with Qt

Presenter:Roland Krause – ICS

Abstract:
When targeting today’s embedded devices, typically based on low power ARM CPU architecturem Qt is a “Best in Class” Software Development Kit. After introducing some of the hardware software combinations that are commonly used in industrial, consumer and R&D applications we will show Qt’s native support for developing modern applications that incorporate touch and sensor input. Further, best practices when setting up the development environment will be shown. Common concepts of connecting target devices to host hardware, techniques for deploying applications and debugging and profiling concepts will be discussed.

Presenter Biography:
Roland is a Qt Consulting Manager for Integrated Computer Solutions, Inc. (ICS), with over ten years’ experience in research, development, architecture and design of simulation software for the Biotechnology, Civil and Mechanical Engineering Industries.

Roland studied at the Universität Dortmund, holds both a Masters and Doctorate Degree in Engineering and he worked as a Postdoctoral Research Fellow with the German Research Foundation (DFG) at the Cornell Fracture Group, Cornell.

Qt for Embedded Device Creation

Presenters: Tuukka Ahoniemi & Sinan Tanilkan

Abstract:
Even though the origins of Qt lay in cross-platform development, over the years Qt has proven to be a powerful resource saving tool in embedded device creation. The developer story of Qt on embedded has formed mainly around the ability to create high-performing, modern and scalable user interfaces even for embedded devices with limited resources. The other important value of Qt on Embedded is in the power of native C++ libraries providing direct device access and optimization possibilities. With the Qt Creator IDE and the new “Boot to Qt” project, Qt is also enormously facilitating the developer’s workflow encouraging rapid UI prototyping and providing easy device deployment.

In this session we will present and discuss the usage of Qt in the context of creating embedded devices. We will discuss real-life use cases, talk about developer workflow and introduce the new and exciting “Boot to Qt” project, which provides an out-of-the-box SDK and device software stack for Qt powered embedded device creation.

Presenter Biographies:
Tuukka Ahoniemi:
Tuukka works with the product marketing of Qt, Digia. For the past years he has traveled around the world spreading the message of Qt supremacy in the form of having held over 100 Qt training courses, speaking in various conferences and trade shows. Still trying to “finish” his PhD he holds a M.Sc (tech) in Computer Sciences with the background in academic teaching of programming and research around it. Still being passionate about teaching he is a certified Qt trainer, Nokia Developer Certified Trainer, Certified Qt Specialist and a Nokia Developer Champion. “A man this ugly needs something Qt in his life”, describes Tuukka and his deep feelings towards the framework. Tuukka is based in Tampere, Finland.

Sinan Tanilkan – Senior Manager, Digia:
Sinan is part of the Qt R&D management team at Digia, responsible for embedded, Qt for Android and web in Qt. Previously he was the release and program manager for Qt 4.8 and Qt 5.0. Sinan holds a Cand. scient. degree in software effort estimation from the University of Oslo.

Using Qt 5 on the QNX OS and the QNX CAR Platform for Infotainment

Presenter: Grant Courville, QNX

Short Abstract:
If you are interested in finding out more about the QNX operating system, the QNX CAR Platform, and how we have integrated and optimized Qt 5, then this session is for you.

The QNX operating system and the QNX CAR Platform run in millions of deployed systems, from mobile devices and in-car infotainment units to industrial controllers and medical instruments. Over the past few years, QNX Software Systems has invested significantly to port, integrate, and optimize Qt for the QNX OS and the QNX CAR Platform, enabling developers and OEMs to take advantage of the power of Qt 5 on QNX technology. This session will provide an overview of the QNX OS, the QNX CAR Platform, and our experience with Qt 5.

Abstract:
The QNX operating system and the QNX CAR Platform run in millions of deployed systems, from mobile devices and in-car infotainment units to industrial controllers and medical instruments. Over the past few years, QNX Software Systems has invested significantly to port, integrate, and optimize Qt for the QNX OS and the QNX CAR Platform, enabling developers to take advantage of the power of Qt 5 on QNX technology. This session will provide an overview of the QNX OS, the QNX CAR Platform, and how we see Qt 5 being embraced by automakers and OEMs worldwide.

  • Overview of the QNX OS
  • Overview of QNX CAR Platform for Infotainment
  • Automotive software challenges – why is Auto so hard?
  • Overview of UI trends and technologies: Qt 5, HTML5, OpenGL
  • Qt 5: optimized, integrated and deployed on the QNX OS today
  • How to get started with Qt 5 on the QNX OS

Presenter Biography:
As director of product management at QNX Software Systems, Grant Courville is responsible for managing the company’s global product strategy across a broad range of markets, including automotive, industrial, M2M, and medical. His more than 25 years of experience in the embedded industry includes 20 years with QNX in a wide range of roles: software development, engineering management, application engineering, and sales and services. Grant’s QNX experience is complemented by prior leadership positions with Curtiss-Wright Controls and Tilcon Software.

Developing with Qt and Cascades for BlackBerry 10

Presenters: Vladimir Minenko & Erin Rahnenfuehrer, BlackBerry

Abstract:
The talk will give you a hands-on overview how you can use your Qt knowledge to develop apps for the BlackBerry 10 platform. We will start with a simple “Hello World” Qt app and first take a look what is available on the tooling side. After, this we will take a look on the Cascades UI framework and show you how it uses Qt. We will port our sample app to use Cascades on the UI side and add some features using platform API. At the end of the talk you will know how to start using Qt on the BlackBerry 10 platform or use it for learn Qt on mobile devices. If you like to follow examples on your development machine during the talk, please download, install and setup Qt Creator 2.8 or 3.0 (if available) via this link http://download.qt-project.org/ as well as the recent version of the BlackBerry 10 native SDK as well as the Simulator available under this link: https://developer.blackberry.com/native/downloads/. Alternatively, you can come to the accompanying talk “Setting up your computer for BlackBerry 10 development” where we will help you with all related steps and answer detailed questions.

Presenter Biographies
Vladimir Minenko started working with Qt some while before he joined Trolltech in 2006. He was leading various Qt development projects in Trolltech and in Nokia in the last six years. Since summer 2012, he is the leading the Qt team in BlackBerry and is responsible for Qt on the BlackBerry 10 platform.

Erin Rahnenfuehrer is an Application Development Consultant at BlackBerry and helps developers write Native and Cascades applications. She has been programming since the age of 10 when her parents bought the family’s first computer, a Commodore 64. Prior to joining BlackBerry Erin worked as a Software Developer in both the consumer and enterprise markets.

Qt Development Tools

Presenters: Tobias Nätterlund + Volker Krause (KDAB)

Abstract:
You cannot talk about Qt without also mentioning a number of essentials tools in its toolbox. This presentation will talk about three such tools, namely:

  • Qt Creator- the unbeatable IDE for Qt development. Qt Creator is the cross
    platform equivalent of Microsoft Visual Studio or Eclipse, but in contrast to
    its two competitors it is tailored directly for Qt and QtQuick development.
  • Squish – a tool for writing black box tests. With Squish you can simply
    record and play back tests
  • Gamaray – a “debugging” tool that lets you peek into your Qt applications to
    see the object tree, the current state of a state machine, the geometry of the
    user interface elements, among many other things.

Presenter Biographies:
Volker Krause
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.

Tobias Nätterlund
Tobias has actively developed with Qt since 2006, and is the co-author of KDAB’s Squish training material. He was also the maintainer of KDAB’s automated testing tool for several years. He holds an MS in Computer Science and has held Squish training courses in Germany as well as in Sweden.

Developing with Qt for IOS and Android

Presenters:Gustavsen Richard (Digia) + Bogdan Vatra (KDAB)

Abstract:
With Qt 5.2, Qt will ship with support for iOS and Android. This talk is a presentation on what you need to know when creating Qt applications for these platforms, from code to deployment. This includes which modules are currently supported, how to use Qt with Xcode (for iOS) and QtCreator (for Android), mixing with native API’s, how to prepare your application for App Store/Google Play Store, and more.

Presentation

Strategic relevance of Qt

Presenter: Till Adam (KDAB)

Abstract:
It is easy to be enthusiastic about the technical merits of Qt. For those having to make technology choice decisions that impact the business for potentially a long time, that is not the only dimension, however. Risks need to be examined and trade-offs identified, medium and long term impact on all aspects of one’s product and business rationally and fully assessed. From HR to IP issues, new strategic opportunities and options to structural considerations relative to recent market developments, this presentation will strive to shed a light on where Qt sits on the strategic map. What does it bring to the table and where does it expose risks that need to be mitigated? How can that be done? What does an organization adopting Qt need to keep and mind and where can it generate additional value thanks to Qt?

Presenter Biography:
Originally from a liberal arts background, Till Adam is a long time contributor to several Open Source technologies and a veteran of Qt consulting. He has taught Qt and its advanced use to individuals and organizations across the world and helped architect, implement, debug and profile a wide variety of applications across many different domains. Till is responsible for services at KDAB, frequently presents and occasionally publishes on technical and non-technical topics. He lives in Berlin.

Introduction to QtQuick for modern UI development

Presenters: Stephen Kelly (KDAB) & Jens Bache-Wiig (Digia)

Abstract:
This session will introduce attendees to QtQuick, the technology, UI declaration language, tooling and API for creating modern UIs with Qt.

The session will show how QtQuick code differs fundamentally from C++ code for writing and reasoning about code. Tooling, code and real-world demos will show how QtQuick assists with rapid development in a multi-disciplined team. The range of APIs available for creating applications with QtQuick will also be shown as well as some APIs for extending it with new functionality.

Presenter Biography:
Jens Bache-Wiig:
Jens is a Senior Software Engineer at Digia and holds a M.Sc. in computer science from the Norwegian University of Science and Technology (NTNU). He is a pixel perfectionist and likes to focus on styling, platform integration and improving Qt Quick.

Stephen Kelly:
Stephen has been a professional Qt developer for over 4 years and has worked non-professionally with it for over 7 years. At KDAB he has worked with and on the model-view system in Qt 4 and Qt 5, as well as numerous other frameworks within Qt such as the state machine framework, the scripting framework and various UI integration.

Stephen is the maintainer in the Qt project of the itemviews system and the CMake files provided by Qt 5.

Starter Edition – Hands-on Tracks

Play with QtQuick

Bring your laptop to this session to get hands on experience with Qt Quick. Please have Qt downloaded an installed before hand. You can download it from http://qt-project.org/downloads

Play with QtQuick or Qt Widgets

Bring your laptop to this session to get hands on experience with Qt Quick or Qt Widgets at your digression. Please have Qt downloaded an installed before hand. You can download it from http://qt-project.org/downloads

Testing With Squish

Presenter: Harry Porten – Froglogic

Join this session to get some hand on experience with Squish. Representatives from Froglogic will be there to help you install it on your computer, to help you though the first step of it, and to discuss future plans for Squish.

Setting up your computer for Android or iOS Development

Bring your laptop and Android or iOS device to this session to get it set up for development. Once it is up and running you are ready to deploy your first Qt application on the device.

Setting up your computer for BB10 development

Presenters: Vladimir Minenko & Erin Rahnenfuehrer, BlackBerry

Bring your laptop and BlackBerry 10 device to get it set up for development. Once it is up and running you are ready to deploy your first Qt and or Cascades application on the device.

In preparation, you might download and install Qt Creator 2.8 or 3.0 (if available) via this link http://download.qt-project.org/ as well as the recent version of the BlackBerry 10 native SDK as well as the Simulator available under this link: https://developer.blackberry.com/native/downloads/.