The document provides performance tips for Qt/QML applications. It recommends:
1. Using C++ rather than JavaScript for business logic and long-running operations to avoid blocking the UI.
2. Loading content dynamically with Loaders and partitioning the UI into logical components to improve startup speed.
3. Caching images at their native size and resolution, loading images asynchronously, and avoiding unnecessary resizing or compositing of images to reduce memory usage and improve performance of visual elements.
4. Optimizing data models and use of cache buffers to improve the performance of scrolling in lists and grids.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for this webinar to explore the best of QML for mobile, embedded and desktop.
Part III will cover:
- C++ Backends
- Reusing existing code
- Creating QML Modules
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 1 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 1 will cover:
Building Blocks of QML
Qt Properties
Declarative Code
Anchors
This presentation and we will explore some of the more complex areas of QML and present tips, tricks, best practices and common areas of error and confusion. The material is based on real-world experience developing customer applications for mobile, embedded and desktop.
Part II covers:
- Anchors
- Creating New Items
- States and Transitions
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for this webinar to explore the best of QML for mobile, embedded and desktop.
Part IV will cover:
- Dynamic Item Creation
- Keyboard Input Handling
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us as we explore the best of QML for mobile, embedded and desktop.
Part I will cover:
- Building Blocks of QML
- Qt Properties
- Declarative Code
QVariant, QObject — Qt's not just for GUI developmentICS
In part II of our Qt for Beginners Summer Webinar Series we will explore how Qt is so much more than just a GUI toolkit. Through two classes, QObject and QVariant, Qt brings us introspection, makes it easier to manage memory in C++ and makes it easier to decouple classes.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for this webinar to explore the best of QML for mobile, embedded and desktop.
Part III will cover:
- C++ Backends
- Reusing existing code
- Creating QML Modules
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 1 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 1 will cover:
Building Blocks of QML
Qt Properties
Declarative Code
Anchors
This presentation and we will explore some of the more complex areas of QML and present tips, tricks, best practices and common areas of error and confusion. The material is based on real-world experience developing customer applications for mobile, embedded and desktop.
Part II covers:
- Anchors
- Creating New Items
- States and Transitions
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for this webinar to explore the best of QML for mobile, embedded and desktop.
Part IV will cover:
- Dynamic Item Creation
- Keyboard Input Handling
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us as we explore the best of QML for mobile, embedded and desktop.
Part I will cover:
- Building Blocks of QML
- Qt Properties
- Declarative Code
QVariant, QObject — Qt's not just for GUI developmentICS
In part II of our Qt for Beginners Summer Webinar Series we will explore how Qt is so much more than just a GUI toolkit. Through two classes, QObject and QVariant, Qt brings us introspection, makes it easier to manage memory in C++ and makes it easier to decouple classes.
The model/view design pattern is the standard way of separating UI from business logic, especially when the data exchanged is dynamic. In a series of blog posts released in May, we presented an introduction to model/view design and provided an example of how this pattern is leveraged in Qt applications. In this webinar, we will go more in depth, illustrating model/view with a set of two QML programming examples. The first will consider the simple case where data size remains constant. The second will cover the more common situation where data size is dynamic.
Practical QML - Key Navigation, Dynamic Language and Theme ChangeBurkhard Stubert
This is the presentation "Practical QML" that I gave at the Qt Developer Days 2013 in Berlin and San Francisco.
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.
Then, I'll show how to switch between different languages and between different themes at run-time.
Interacting with the Qt Quick scene graph is a good bonus skill for any Qt developer to have. In this introductory webinar we will present this component: a graphical representation of the Item scene and an alternative method to QML coding. Proper use of the underlying scene graph can save performance at runtime. We will explore how to interact with the scene graph through a simple example and suggest when it is appropriate to use.
OpenGL is a powerful, low-level graphics toolkit with a steep learning curve that allows access to accelerated GPU hardware. Using OpenGL, developers achieve high fidelity, animated graphics ubiquitous in games, screen productions and scientific software.
Join us for a one-hour webinar and we will give a comprehensive overview of the many aspects of OpenGL development where Qt provides advanced interfaces that let the developer focus on the tasks instead of dealing with repetitive and error-prone, platform dependent issues.
The next version of Qt adds a framework for defining and executing hierarchical finite state machines in Qt applications. With Qt State Machines you can effectively model how components react to events over time; these state machines are a natural extension to Qt's event-driven programming model. State machines allow you to express the behavior of your application in a more rigid, explicit way, resulting in code that's easier to test, maintain and extend. This session presents the core concepts and functionality of Qt State Machines.
Presentation by Kent Hansen held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
There is ongoing confusion, and some contention, over the right way to use the QThread class. Part of the confusion comes from the uniqueness of QThread, which is significantly different from other threading classes. There are two valid patterns of QThread use, and each pattern is best suited for different use cases. Errors will arise when mixing these two patterns, or applying them inappropriately.
This presentation will look at different patterns of threading in general, and examine in detail the two usage patterns for QThread. This talk will also cover how QThread works inside, how to communicate between threads, provide examples, and point out the pitfalls to avoid.
We start with an introduction to what Apache Camel is, and how you can use Camel to make integration much easier. Allowing you to focus on your business logic, rather than low level messaging protocols, and transports. You will also hear what other features Camel provides out of the box, which can make integration much easier for you.
We look into web console tooling that allows you to get insight into your running Apache Camel applications, which has among others visual route diagrams with tracing/debugging and profiling capabilities. In addition to the web tooling we will also show you other tools in the making.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 3 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 3 will cover:
C++ / QML Integration
Reusing Existing C++ Code
Design Patterns help us solve problems in tried and tested ways.
Turns out they also help us understand our framework better, for framework developers also use patterns.
In these slides you'll see how Design Patterns are implemented by Qt framework, to better both understand patterns and Qt
How to test-drive your Qt QML code. Overview on how you do simple testing, UI level testing, synchronous testing, data-driven testing.
These are the slides used on the Tampere MeeGo meetup on March 15, 2011 and text may not be super clear for those who didn't attend the meetup. You can still download the example and examine it.
The model/view design pattern is the standard way of separating UI from business logic, especially when the data exchanged is dynamic. In a series of blog posts released in May, we presented an introduction to model/view design and provided an example of how this pattern is leveraged in Qt applications. In this webinar, we will go more in depth, illustrating model/view with a set of two QML programming examples. The first will consider the simple case where data size remains constant. The second will cover the more common situation where data size is dynamic.
Practical QML - Key Navigation, Dynamic Language and Theme ChangeBurkhard Stubert
This is the presentation "Practical QML" that I gave at the Qt Developer Days 2013 in Berlin and San Francisco.
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.
Then, I'll show how to switch between different languages and between different themes at run-time.
Interacting with the Qt Quick scene graph is a good bonus skill for any Qt developer to have. In this introductory webinar we will present this component: a graphical representation of the Item scene and an alternative method to QML coding. Proper use of the underlying scene graph can save performance at runtime. We will explore how to interact with the scene graph through a simple example and suggest when it is appropriate to use.
OpenGL is a powerful, low-level graphics toolkit with a steep learning curve that allows access to accelerated GPU hardware. Using OpenGL, developers achieve high fidelity, animated graphics ubiquitous in games, screen productions and scientific software.
Join us for a one-hour webinar and we will give a comprehensive overview of the many aspects of OpenGL development where Qt provides advanced interfaces that let the developer focus on the tasks instead of dealing with repetitive and error-prone, platform dependent issues.
The next version of Qt adds a framework for defining and executing hierarchical finite state machines in Qt applications. With Qt State Machines you can effectively model how components react to events over time; these state machines are a natural extension to Qt's event-driven programming model. State machines allow you to express the behavior of your application in a more rigid, explicit way, resulting in code that's easier to test, maintain and extend. This session presents the core concepts and functionality of Qt State Machines.
Presentation by Kent Hansen held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
There is ongoing confusion, and some contention, over the right way to use the QThread class. Part of the confusion comes from the uniqueness of QThread, which is significantly different from other threading classes. There are two valid patterns of QThread use, and each pattern is best suited for different use cases. Errors will arise when mixing these two patterns, or applying them inappropriately.
This presentation will look at different patterns of threading in general, and examine in detail the two usage patterns for QThread. This talk will also cover how QThread works inside, how to communicate between threads, provide examples, and point out the pitfalls to avoid.
We start with an introduction to what Apache Camel is, and how you can use Camel to make integration much easier. Allowing you to focus on your business logic, rather than low level messaging protocols, and transports. You will also hear what other features Camel provides out of the box, which can make integration much easier for you.
We look into web console tooling that allows you to get insight into your running Apache Camel applications, which has among others visual route diagrams with tracing/debugging and profiling capabilities. In addition to the web tooling we will also show you other tools in the making.
Qt Quick/QML brings designers and developers together to create and collaborate. QML is a collection of technologies that can build modern and fluid interfaces for applications – quickly. Join us for part 3 of our 4 part webinar series where we explore the best of QML for mobile, embedded and desktop.
Part 3 will cover:
C++ / QML Integration
Reusing Existing C++ Code
Design Patterns help us solve problems in tried and tested ways.
Turns out they also help us understand our framework better, for framework developers also use patterns.
In these slides you'll see how Design Patterns are implemented by Qt framework, to better both understand patterns and Qt
How to test-drive your Qt QML code. Overview on how you do simple testing, UI level testing, synchronous testing, data-driven testing.
These are the slides used on the Tampere MeeGo meetup on March 15, 2011 and text may not be super clear for those who didn't attend the meetup. You can still download the example and examine it.
Performance is a key component of usability and crucial for the user experience, especially in today's modern user interfaces where graphical elements are being animated and transitioned. Bringing Qt Everywhere means a significant need for speed across desktop and embedded platforms. This presentation will give you a brief overview of performance improvements done in Qt, and will be highly interactive with hands-on sessions on how to squeeze every last drop of performance out of your Qt application.
Presentation by Bjørn Erik Nilsen held during Qt Developer Days 2009.
http://qt.nokia.com/whatsnew
Everything you want to know about QWidget, but were afraid to ask. QWidget is the base-class for all Qt's user interface objects. This talk will take an in-depth look at how QWidget works internally and how it interacts with the native windowing system.
Presentation by Marius Bugge Monsen held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Case Study: Using Qt to Develop Advanced GUIs & Advanced Visualization Softwareaccount inactive
DAZ 3D strives to bring 3D art to the masses by delivering the highest quality 3D digital content and software at the most affordable prices. DAZ Studio is a free, feature rich 3D figure design and 3D animation tool that enables anyone to create stunning digital imagery. This is the perfect tool to design unique digital art and animation using virtual people, animals, props, vehicles, accessories, environments and more. In April of 2004, DAZ started the Public Beta release stage of development for DAZ Studio after two years of development. In June 2009, DAZ Studio v3.0 was released both as a free version and a monetized advanced version. This presentation will explain why Qt was originally selected, what benefits have been realized from it’s use in DAZ Studio, and what DAZ 3D’s experience has been in porting there app from Qt3.3 to Qt4.5. Specific topics will include scripting implementation, cross-platform compatibility, UI versatility, upgrade porting issues/experiences, benefits of the 4.5 opensource version, and styling benefits.
Presentation by Tyson Ratliff and Jarom Schow held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Qt uses native style APIs on each supported platform, however there are some additional tricks you can use to make sure your Qt-based application looks, feels and behaves better. This presentation will run through examples, tips and ticks to help you make your applications look great on all platforms.
Presentation by Jens Bache-Wiig held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
"How to Develop with Qt for Multiple Screen Resolutions and Increase Your Use...FELGO SDK
*** NOTE ***
A summarized version is available here:
http://v-play.net/2014/11/supporting-multiple-screen-sizes-and-screen-densities-with-qt-and-v-play
*** Quick Summary ***
In the first part, we show how to use Qt Quick features to create UIs for multiple screen sizes, screen resolutions and form factors like phones, tablets and desktop PCs. We cover dynamic image switching, content scaling and basic Qt Quick features like file selectors, Loader elements, QML Singletons and property bindings and compare the use cases for each of them.
We also cover how to implement adaptive layouts and responsive design in Qt and V-Play. Plus, how to create density independence and HighDPI / Retina screen support.
The second part shows:
•How to increase user engagement with user-generated content and how to build a community around your app or game.
• How gamification can be added to apps or games in just a few minutes and its benefits.
*** Presentation Keywords ***
Qt, Qt Quick, QML, JavaScript, V-Play Game Engine, V-Play Qt 5 Plugins
Screen density, screen resolution, screen size
Density independence, density-independent pixels; pixel density
Dynamic image switching, dynamic image selection; Android: alternative bitmaps; retina display, retina images
High dpi screens
Multiple screen aspect ratios
Supporting Multiple Screens, Responsive Design (tablet layout, adaptive layout, adaptable layout, scalability)
Multiple resolutions
Content scaling, upscaling, adaptive scaling
User Retention, User-Generated Content, UGC, community building, V-Play Game Network, Gamification
Qt 5 Plugins, V-Play Plugins, Qt Facebook Plugin, Qt Chartboost, Qt AdMob, Qt Flurry Analytics, Qt Push Notifications, Qt In-App Purchases
This is the presentation from the Ask the Expert: App performance on Series 40 phones webinar. In this presentation, Michael Samarin of Futurice, provides an overview to the key issues that should be considered when designing Series 40 Java apps for optimum performance. Michael covers issues such as selecting the technology for your GUI, memory considerations, obfuscation, objects, variable, and caching among others.
Top 7 Angular Best Practices to Organize Your Angular AppKaty Slemon
Learn about Angular best practices to improve the performance of your existing Angular application. Tried and tested clean code checklist for your Angular app.
Developing high performance and responsive web apps using web workerSuresh Patidar
A brief talk on web application performance and responsiveness. Why it is important and how web worker can help achieve it. It also covers a simple example implementing web workers.
In this presentation, you’ll explore the new Series 40 web app APIs and features of Nokia Web Tools 2.0. Expert Michael Samarin from Futurice will show you how to develop for new Nokia Asha phones with a full-touch UI and will give you an overview of new templates and code samples.
Presentation from DDD Sydney, May 28th, 2016
Buzz word! More buzz words! And another buzz word!! Now that that's out of the way, if you're thinking of heading down the microservices path, then how do you do it? How do you build the services? What do you need to think about if you're starting from scratch? What if you're converting a legacy app? How do we deal with versioning? Do we have to use a NoSQL solution, just because Netflix does? Do we need to use docker/containers? What about the code? Show me the code! Well, that's what this session is all about. Designing and building microservices in .NET and then handling a bunch of other concerns that a microservices approach will force you to think about. Sounds interesting, doesn't it? You betcha.
NodeJS : Communication and Round Robin WayEdureka!
Node.js uses JavaScript - a language known to millions of developers worldwide - thus giving it a much lower learning curve even for complete beginners. Using Node.js you can build simple Command Line programs or complex enterprise level web applications with equal ease. Node.js is an event-driven, server-side, asynchronous development platform with lightning speed execution. Node.js helps you to code the most complex functionalities in just a few lines of code.
Dark launching with Consul at Hootsuite - Bill MonkmanAmbassador Labs
Dark Launching (A.K.A. Feature Flagging) is a technique and mindset that has truly shaped the way we write, test, and deploy code at Hootsuite. It gives our team realtime, fine-grained control over our production systems which helps to prevent issues from reaching users, and build developer confidence in a culture of pushing code many times per day.
In this presentation I will go over how the system helps us both in the context of microservices and monoliths, and how we made use of Consul, Hashicorp's HA service discovery / KV store, to make it more resilient and performant at scale.
Building reusable components as micro frontends with glimmer js and webcompo...Andrei Sebastian Cîmpean
Reusing features across multiple stacks. A story of trade-offs and approach choices to make it easy to run features independent of the tech stack in which they are running.
Similar to Qt and QML performance tips & tricks for Qt 4.7 (20)
Key Trends Shaping the Future of Infrastructure.pdfCheryl Hung
Keynote at DIGIT West Expo, Glasgow on 29 May 2024.
Cheryl Hung, ochery.com
Sr Director, Infrastructure Ecosystem, Arm.
The key trends across hardware, cloud and open-source; exploring how these areas are likely to mature and develop over the short and long-term, and then considering how organisations can position themselves to adapt and thrive.
Dev Dives: Train smarter, not harder – active learning and UiPath LLMs for do...UiPathCommunity
💥 Speed, accuracy, and scaling – discover the superpowers of GenAI in action with UiPath Document Understanding and Communications Mining™:
See how to accelerate model training and optimize model performance with active learning
Learn about the latest enhancements to out-of-the-box document processing – with little to no training required
Get an exclusive demo of the new family of UiPath LLMs – GenAI models specialized for processing different types of documents and messages
This is a hands-on session specifically designed for automation developers and AI enthusiasts seeking to enhance their knowledge in leveraging the latest intelligent document processing capabilities offered by UiPath.
Speakers:
👨🏫 Andras Palfi, Senior Product Manager, UiPath
👩🏫 Lenka Dulovicova, Product Program Manager, UiPath
LF Energy Webinar: Electrical Grid Modelling and Simulation Through PowSyBl -...DanBrown980551
Do you want to learn how to model and simulate an electrical network from scratch in under an hour?
Then welcome to this PowSyBl workshop, hosted by Rte, the French Transmission System Operator (TSO)!
During the webinar, you will discover the PowSyBl ecosystem as well as handle and study an electrical network through an interactive Python notebook.
PowSyBl is an open source project hosted by LF Energy, which offers a comprehensive set of features for electrical grid modelling and simulation. Among other advanced features, PowSyBl provides:
- A fully editable and extendable library for grid component modelling;
- Visualization tools to display your network;
- Grid simulation tools, such as power flows, security analyses (with or without remedial actions) and sensitivity analyses;
The framework is mostly written in Java, with a Python binding so that Python developers can access PowSyBl functionalities as well.
What you will learn during the webinar:
- For beginners: discover PowSyBl's functionalities through a quick general presentation and the notebook, without needing any expert coding skills;
- For advanced developers: master the skills to efficiently apply PowSyBl functionalities to your real-world scenarios.
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
UiPath Test Automation using UiPath Test Suite series, part 4DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 4. In this session, we will cover Test Manager overview along with SAP heatmap.
The UiPath Test Manager overview with SAP heatmap webinar offers a concise yet comprehensive exploration of the role of a Test Manager within SAP environments, coupled with the utilization of heatmaps for effective testing strategies.
Participants will gain insights into the responsibilities, challenges, and best practices associated with test management in SAP projects. Additionally, the webinar delves into the significance of heatmaps as a visual aid for identifying testing priorities, areas of risk, and resource allocation within SAP landscapes. Through this session, attendees can expect to enhance their understanding of test management principles while learning practical approaches to optimize testing processes in SAP environments using heatmap visualization techniques
What will you get from this session?
1. Insights into SAP testing best practices
2. Heatmap utilization for testing
3. Optimization of testing processes
4. Demo
Topics covered:
Execution from the test manager
Orchestrator execution result
Defect reporting
SAP heatmap example with demo
Speaker:
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Neuro-symbolic is not enough, we need neuro-*semantic*Frank van Harmelen
Neuro-symbolic (NeSy) AI is on the rise. However, simply machine learning on just any symbolic structure is not sufficient to really harvest the gains of NeSy. These will only be gained when the symbolic structures have an actual semantics. I give an operational definition of semantics as “predictable inference”.
All of this illustrated with link prediction over knowledge graphs, but the argument is general.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Search and Society: Reimagining Information Access for Radical FuturesBhaskar Mitra
The field of Information retrieval (IR) is currently undergoing a transformative shift, at least partly due to the emerging applications of generative AI to information access. In this talk, we will deliberate on the sociotechnical implications of generative AI for information access. We will argue that there is both a critical necessity and an exciting opportunity for the IR community to re-center our research agendas on societal needs while dismantling the artificial separation between the work on fairness, accountability, transparency, and ethics in IR and the rest of IR research. Instead of adopting a reactionary strategy of trying to mitigate potential social harms from emerging technologies, the community should aim to proactively set the research agenda for the kinds of systems we should build inspired by diverse explicitly stated sociotechnical imaginaries. The sociotechnical imaginaries that underpin the design and development of information access technologies needs to be explicitly articulated, and we need to develop theories of change in context of these diverse perspectives. Our guiding future imaginaries must be informed by other academic fields, such as democratic theory and critical theory, and should be co-developed with social science scholars, legal scholars, civil rights and social justice activists, and artists, among others.
Search and Society: Reimagining Information Access for Radical Futures
Qt and QML performance tips & tricks for Qt 4.7
1. Performance tips and tricks for Qt/QML
applications
General
Do not use JavaScript, but rather implement the UI with QML and the
engine with C++
JavaScript should be avoided as much as possible. Do not use it at all.
JavaScript code should be kept to a minimum. C++ should be used to implement
application's the business logic.
JavaScript is especially bad for performance when it is run during animation, e.g. in lists
the JavaScript monster gets evaluated on every frame of the scrolling animation as many
times as there are instantiated delegates.
If you must use JavaScript anyway, simplify your JavaScript expressions as much as
possible and write them inline if they fit on one line. QML is compiled to an optimized
bytecode-like stream and the JavaScript expressions pass through an optimized evaluator
for simple expressions. More
info: http://doc.qt.nokia.com/latest/qdeclarativejavascript.html#inline-javascript
It is also recommended to set values for properties using QML property binding
than JavaScript value assignment
Wrong:
itemTitle: {
if(targetFeedItem == null){
return "";
}
return targetFeedItem.title;
}
Right:
itemTitle: targetFeedItem == undefined ? "" : targetFeedItem.title;
2. Use threads or multiprocessing to allow responsive UI
If you don't use threads for long-lasting operations, the UI is blocked. Use threads for the long lasting
operations such as data retrieval to keep UI responsive.
In QML the WorkerScript element can be used to run JavaScript operations in a new thread
(you shouldn't use JavaScript in a serious application)
o DO NOT use multiple WorkerScripts or you are in trouble.
o If you initialize a large list synchronously in a JavaScript block (this is something that
a serious application would never do...) it is very likely that UI jamming will occure
with high memory consumption. The memory consumption is likely due to the fact
that garbage collector does not get a chance to collect any items while a
synchronous loop is processing.
o More info on WorkerScript: http://doc.qt.nokia.com/latest/qml-workerscript.html
C++ threads should be used for all serious applications
o This can be done by creating a QDeclarativeExtensionPlugin and exposing the
needed QObjects to QML
o In the QObject one exposes the properties, invokable methods, signals and slots
needed in the UI
o For any long (>2ms) operations one should use QRunnable with QThreadPool or
QFuture see. More info: http://doc.trolltech.com/latest/threads.html
o The long lasting operations (> N ms) must be implemented as asyncronous server
calls or by using threads so that the UI can update itself while the application is doing
long lasting backend operations
Use anchors rather than bindings to position items relative to each other
Wrong way to bind rect2 to rect1:
Rectangle {
id: rect1
x: 20
width: 200; height: 200
}
Rectangle {
id: rect2
3. x: rect1.x
y: rect1.y + rect1.height
width: rect1.width - 20
height: 200
}
Right way to do this, anchor rect2 to rect1:
Rectangle {
id: rect1
x: 20
width: 200; height: 200
}
Rectangle {
id: rect2
height: 200
anchors.left: rect1.left
anchors.top: rect1.bottom
anchors.right: rect1.right
anchors.rightMargin: 20
}
More info: http://doc.qt.nokia.com/latest/qdeclarativeperformance.html#anchors-vs-binding
4. App start
Use Booster
On Symbian and MeeGo it is possible to speed up application start by picking up pre-instantiated
QApplication and QDeclarativeView from cache. Please contact Nokia for details how to do this.
Use loaders to dynamically load/unload QML
QML application starts quite slow if the whole application is implemented in one huge QML file.
Partition our application wisely into logical entities, load minimum QML at start and load more as you
need it using Loaders .
The Loader item can be used to dynamically load and unload visual QML components
defined in a QML file or items/components defined within a QML file
This dynamical behavior allows the developer to control the memory usage and startup
speed of an application. More info: http://doc.qt.nokia.com/latest/qml-loader.html#details
Partition your application into several QML files so that each file contains a logical UI entity.
This way loading and unloading are easier to control. DO NOT have one huge QML file per
application.
Load absolutely minimum amount of QML at application start to make your application start
as quickly as possible. You can connect to network and show spinner etc. after the
application UI is visible. If your first view is very complex and requires lots of QML to be
loaded, show a splash screen or something.
You should load pieces of UI only by demand e.g. when the user navigates to another view,
but on the other hand it may require more time to navigate between views
Creating a dialog can take more than 100ms of time. Make sure you use Loader to load
the dialog.
import QtQuick 1.0
Item {
width: 200; height: 200
Loader { id: pageLoader }
6. Images
Bitmap formats vs. vector graphics formats
Images can be supplied in any of the standard image formats supported by Qt, including bitmap
formats such as PNG and JPEG, and vector graphics formats such as SVG.
However, rendering an SVG is slow compared to a bitmap image.
Load large images asynchronously
If you load images synchronously the UI is blocked. In many cases images are not needed visible
immediately, but they can be lazy-loaded.
You should load images asynchronously in a separate thread if an image doesn't need to be
displayed immediately. This can be done by settings QML Image asynchronous to true.
This way the user interface stays responsive user interface.
Note that this property is only valid for images read from the local filesystem. Images that are
loaded via a network resource (e.g. HTTP) are always loaded asynchonously.
More info: http://doc.qt.nokia.com/latest/qml-image.html#asynchronous-prop
Avoid resizing/scaling
Resizing/scaling is a very heavy operation in QML. Use images that are in their native size rather
than resize/scale large images to correct size.
Use sourceSize with large images
Images are often the greatest user of memory in QML user interfaces.
sourceSize should be used with large images because property sets the actual number of
pixels stored for the loaded image
If you have a HUGE image 3264 x 2448, but you set sourceSize 204x153, then it scaled
down and will be stored as 204x153 in memory.
If the image's actual size is larger than the sourceSize, the image is scaled down. This way
large images do not use more memory than necessary.
This is especially important for content that is loaded from external sources or provided by
the user
Beware that changing this property dynamically causes the image source to be reloaded,
potentially even from the network, if it is not in the disk cache.
More info on Image::sourceSize property: http://doc.qt.nokia.com/latest/qml-
image.html#sourceSize-prop
7. Images are cached and shared internally, so if several Image elements have the same
source, only one copy of the image will be loaded.
More info: http://doc.qt.nokia.com/latest/qml-image.html#source-prop
Enable Image.smooth only when necessary
Enabling Image.smooth is bad for performance. Use images in their natural size or disable smooth
filtering in animation.
Image.smooth property causes the image to be smoothly filtered when scaled or transformed
Smooth filtering gives better visual quality, but is slower
If the image is displayed at its natural size, Image.smooth has no visual or performance
effect
If you really need to enable Image.smooth, disable smooth filtering at the beginning of the
animation and re-enable it at the end of the animation (scaling artifacts are only visible if the
image is stationary on the screen)
More info on Image.smooth property: http://doc.qt.nokia.com/latest/qml-image.html#smooth-
prop
Avoid composing an image from a number of elements
It is more efficient to compose an image from a single image than from a number of elements.
For example, a frame with a shadow could be created using a Rectangle placed over an
Image providing the shadow
It is more efficient to provide an image that includes the frame and the shadow
More info: http://doc.qt.nokia.com/latest/painting-imagecomposition.html
More info: http://doc.qt.nokia.com/latest/qdeclarativeperformance.html#image-resources-
over-composition
Lists
Ensure that your data model is as fast as possible
In many cases the slow model is actually the bottleneck in list scrolling performance. Ensure that the
data model is as fast as possible.
Delegates must be created quickly as the view is flicked. In order to keep the UI responsive,
your data() function must handle over 1000 calls in a second.
Any additional functionality that is only needed when the delegate is clicked, for example,
should be created by a Loader as it is needed.
8. Keep the amount of QML to a minimum in your delegate. The fewer elements in a delegate,
the faster a view can be scrolled.
In real-world applicationit is advised to write as much code as possible in C++ and use QML
only for the user interface. This is especially important for list delegates. More
info: http://cdumez.blogspot.com/2010/11/how-to-use-c-list-model-in-qml.html
CacheBuffer usage in ListView/GridView
In somes cases, cacheBuffer can be useful in improving your ListView/GridView performance. The
default cacheBuffer is zero.
cacheBuffer property determines whether delegates are instantiated outside the visible area
of the view
Note that cacheBuffer is defined in pixels, e.g. if delegate is 20 pixels high, cacheBuffer is set
to 40 -> up to 2 delegates above and 2 delegates below the visible area may be retained in
memory
Setting this value can improve the smoothness of scrolling behavior at the expense of
additional memory usage. Data is not cached, but the instantiated delegates that requested
the data are.
Define cacheBuffer if you have a short list where every item can be cached
For longer lists cacheBuffer doesn't bring benefit because items are created at the same rate
as if there were no cache while scrolling fast. The cacheBuffer just postpones the problem,
i.e. only pushes the position where delegates are created further above/below the visible part
of list/grid.
More info: http://doc.qt.nokia.com/latest/qml-listview.html#cacheBuffer-prop
Avoid useless painting
You should always prevent painting the same area several times. For example, prevent
QDeclarativeView from painting its window background if you provide the background of your
application:
QDeclarativeView window;
window.setAttribute(Qt::WA_OpaquePaintEvent);
window.setAttribute(Qt::WA_NoSystemBackground);
window.viewport()->setAttribute(Qt::WA_OpaquePaintEvent);
window.viewport()->setAttribute(Qt::WA_NoSystemBackground);
9. Also, consider using Item as root element rather than Rectangle to avoid painting the background
several times:
If your root element is a Rectangle, you’re painting every pixel, maybe even several times
The system (QDeclarativeView) first paints the background and then paints all the QML
elements
You might have a Rectangle as the root element and inside that you have a lot of elements
without opacity covering most of the Rectangle. In this kind of case the system is doing
useless painting.
You could instead use Item as root element because it has no visual appearance
If you need to paint background, but have static UI elements covering part of the screen, you
can still use Item as the root element and anchor a Rectangle between those static items.
This way you don’t do useless painting.
More info: http://doc.qt.nokia.com/latest/qdeclarativeperformance.html#rendering
http://doc.qt.nokia.com/latest/qml-item.html
http://juhaturunen.com/blog/2011/04/a-qml-rendering-performance-trick-so-simple-that-it-hurts/
10. Other
Fixed length lists with Flickable+Column+Repeater
If you have a simple list with fixed length, you could try to optimize performance using
Flickable+Column+Repeater instead of QML ListView. This way list creation would be slower, but list
scrolling smoother.
Beware of string operations
Multiple uses of the '+' operator usually means multiple memory allocations
Use StringBuilder for more efficient strings. QStringBuilder uses expression templates and
reimplements the '%' operator so that when you use '%' for string concatenation instead of
'+', multiple substring concatenations will be postponed until the final result is about to be
assigned to a QString. At this point, the amount of memory required for the final result is
known. The memory allocator is then called once to get the required space, and the
substrings are copied into it one by one.
Define: QT_USE_FAST_CONCATENATION, QT_USE_FAST_OPERATOR_PLUS
See more: http://doc.trolltech.com/latest/qstring.html#more-efficient-string-construction
Animate as small area of the screen as possible in transition animations
If you need to move 3 elements in a second try moving each at a time in 300ms. The system works
so that it calculates the bounds of items that need repainting and paints everything inside those
bounds. This can be really bad two little things are animating in opposite corners.
Avoid complex clipping
You should enable clipping only when you really need it. The default clip value is false.
If clipping is enabled, an item will clip its own painting, as well as the painting of its children,
to its bounding rectangle
More info on Item.clip: http://doc.qt.nokia.com/latest/qml-item.html#clip-prop
Does it help performance if you strip off comments or white space from
QML files?
Not really. The files are reprocessed into a binary in-memory representation at startup, so by runtime
there should be no performance difference. You might be lucky and get 0.5% improvement, and then
only on start-up, nowhere else.
Avoid unnecessary conversion
11. QML performs a type conversion if the given value for a property does not match with the type
specified for the property. This conversion consumes additional memory.
For example, Image and BorderImage have a source, which is of type url. Conversion is
needed if image source's property is defined as string, it should rather be property url.
Wrong way:
property string messageAvatar: ""
Right way:
property url messageAvatar: ""
Anchors and memory consumption
Anchoring can be done in two ways:
The normal way:
Item {
width: 800
height: 400
Button {
id: button;
objectName: "Button";
anchors.top: parent.top
anchors.left: parent.left
anchors.right: parent.right
text: "Press me";
}
}
This way consumes slightly less memory:
13. Qt C++
Controlling QObject Ownership
Qt Script uses garbage collection to reclaim memory used by script objects when they are no longer
needed (only if QObject has QScriptEngine::ScriptOwnership); an object's memory can be
automatically reclaimed when it is no longer referenced anywhere in the scripting environment. Qt
Script lets you control what happens to the underlying C++ QObject when the wrapper object is
reclaimed, i.e. whether the QObject is deleted or not. You can only do this when you create an
object by passing an ownership mode as the second argument to QScriptEngine::newQObject(). By
default QObjects are "Qt Ownership" == objects are never deleted, even if you try do so in
scriptengine side.http://doc.qt.nokia.com/latest/scripting.html#controlling-qobject-ownership
Turn off sample buffers
Turn off sample buffers, check if the graphical results are acceptable to you.
QGLFormat format = QGLFormat::defaultFormat();
format.setSampleBuffers(false);
QGLWidget *glWidget = new QGLWidget(format);
//### potentially faster, but causes junk to appear if top-level is Item,
not Rectangle
//glWidget->setAutoFillBackground(false);
view->setViewport(glWidget);
Integrating with a QWidget-based UI
Creating large numbers of QDeclarativeView objects may lead to performance degradation.
QDeclarativeView is slower to initialize and uses more memory than a QWidget, and creating
large numbers of QDeclarativeView objects may lead to performance degradation
Iit may be better to rewrite your widgets in QML, and load the widgets from a main QML
widget instead of using QDeclarativeView
QWidgets were designed for a different type of user interface than QML, so it is not always a
good idea to port a QWidget-based application to QML
QWidgets are a better choice if your UI is comprised of a small number of complex and static
elements, and QML is a better choice if your UI is comprised of a large number of simple and
dynamic elements
14. More info: http://doc.qt.nokia.com/latest/qml-integration.html#integrating-with-a-qwidget-
based-ui
Integrating QML with a QGraphicsView-based UI
If you have an existing UI based on the Graphics View Framework, you can integrate QML widgets
directly into your QGraphicsScene . The following QGraphicsView options are recommended for
optimal performance of QML UIs:
QGraphicsView ::setOptimizationFlags(QGraphicsView ::DontSavePainterState)
QGraphicsView ::setViewportUpdateMode(QGraphicsView ::BoundingRectViewportUpdate)
QGraphicsScene ::setItemIndexMethod(QGraphicsScene ::NoIndex)
More info: http://doc.qt.nokia.com/latest/qml-integration.html#integrating-with-a-
qgraphicsview-based-ui
Use showFullScreen()
It is advised to use QDeclarativeView::showFullScreen() instead of QDeclarativeView::show() to
avoid compositing overhead. This should improve the performance a little.
Avoid unnecessary QRegExp construction
QRegExp is faster at matching rather than construction. So if you plan to do a lot of regular
expression matching, construct your QRegExp once, eg as a const static, and use it many times.
Creating QServiceManager instance is costly during application startup
This causes 40-50ms delay for application launch. Create QServiceManager during idle time
instead.
Reduce expense of Qt::SmoothTranformation without reducing image
quality
A combination of Qt::FastTransformation and halfscaling helps to reduce effort for scaling images
without loosing the quality of the resulting image. The trick is to do the scaling in two steps:
1. Scale down to 2 times of the destination size using Qt::FastTransformation
2. Scale to the destination size by averaging two pixels in both dimensions using:
quint32 avg = (((c1 ^ c2) & 0xfefefefeUL) >> 1) + (c1 & c2);
NOTE: Previously we had suggested to scale down to a factor of 1.5 and apply smoothscaling then
however this version should result in much better quality and be much faster. It should be faster as
the new algorithm just requires bit arithmetics and bit shifting. So no floating point operations are
15. needed anymore and there are no branches anymore that would require branch predictions (as
would be the case for all kinds of bilinear filtering).
Drawback: This optimization does not make any sense for smaller images. Therefore we need a
heuristic to decide whether it should be used.
Simple demo implementation:
// Smooth scaling is very expensive (size^2). Therefore we reduce the
size
// to 1.5 of the destination size and using fast transformation
afterwards.
// Therefore we speed up but don't loose quality..
if ( canvasPixmap.size().width() > ( 4 * size.toSize().width() ) ) //
Primitive heuristc to decide whether optimization should be used.
{
// Improve scaling speed by add an intermediate fast
transformation..
QSize intermediate_size = QSize( size.toSize().width() * 2,
size.toSize().height() * 2 );
canvasPixmap = canvasPixmap.scaled( intermediate_size,
aspectRatioMode,
Qt::FastTransformation ); //
Cheap operation!
}
canvasPixmap = canvasPixmap.scaled( size.toSize(),
aspectRatioMode,
Qt::SmoothTransformation ); //
Expensive operation!
Avoid duplicating containers by accident
Qt's container classes like QList, QStringList, QVector, QMap, ... are all implicitly shared. That
means that a simple copy from one to the other (e.g., as a function return value) doesn't cost much:
16. Only a shallow copy is made, i.e. just the container's management structure is really duplicated; the
items are not copied, just a reference counter is incremented.
As long as you don't try to modify the copy, that is. And even then a deep copy (i.e., all items are
copied, too) is only made if the reference counter is greater than 1.
This is why the coding conventions insist that const_iterators should be used whenever possible: A
non-const iterator is a write access to the container, causing a deep copy. begin() and end() on a
non-const (!) container are what get the deep copy started.
Sometimes you get lucky. This code, for example, is harmless:
QDir dir(myPath);
QStringList files=dir.entryList();
for ( QStringList::iterator it=files.begin(); it != files.end(); ++files
) {
myWidget->addItem(*it);
}
But this is just by dumb luck. The call to files.begin() would normally initiate copying
the files QStringList that was returned by dir.entryList(). But since its reference count is back
to 1 after returning from that function, there is no reason for a deep copy; files now holds the only
reference to the items.
Better than relying on dumb luck would be to be explicit:
QDir dir(myPath);
QStringList files=dir.entryList();
for ( QStringList::const_iterator it=files.constBegin(); it !=
files.constEnd(); ++files ) {
myWidget->addItem(*it);
}
Avoid implicit copies caused by operator[]
Not so harmless, however, is this piece of code:
QStringList nameList=myClass.nameList();
if ( nameList[0]==searchName ) { // deep copy of nameList
17. ...
}
This seemingly harmless nameList[0] will cause a deep copy of nameList, duplicating each string
it contains in the process. From this copy, element #0 is taken and compared with searchName.
After the if() statement this temporary copy of nameList is immediately destroyed again.
A lot of operations. And so useless.
Why is a temporary object created? Because nameList[] is an LValue - a value that can be used
on the left side of an assignment - like this:
nameList[0]=someValue;
So this operator[] is a write access on its argument, and Qt's container classes initiate a deep
copy on a write access.
You can get lucky here again: QList etc. have overloaded versions
of operator[]() for const containers. In that case, no deep copy will occur. So this is safe:
void myFunc( const QStringList &nameList )
{
if ( nameList[0]==searchedName) { // no deep copy: nameList is const
...
}
}
But again, this is just dumb luck. Better not rely on it. Better be explicit.
Use at() instead of operator[] if you don't want to assign a value to that element.
Avoid a deep copy with code like that:
QStringList nameList=myClass.nameList();
if ( nameList.at(0)==searchName ) { // no deep copy
...
}
18. In the special case of at(0) it is even a little more efficient and and considerably better readable to
use first() :
QStringList nameList=myClass.nameList();
if ( nameList.first()==searchName ) {
...
}
Prefer first() to at(0) .
Most Qt containers have first(). Regrettably, QString or QByteArray don't.
Avoid connecting to QGraphicsScene ::changed() signal
To avoid rather expensive change area calculations, do not connect to QGraphicsScene ::changed()
signal.
More info: http://doc.qt.nokia.com/latest/qgraphicsscene.html#changed