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
Qt Application Programming with C++ is one of the best Qt QML training and courses in Bangalore India. This workshop is ideal for anyone who want to get started with developing GUI Application using Qt framework. Starting with basics, this workshop covers developing multi-threaded, multimedia and 2D graphics based applications with multiple Do-It-Yourself (DIY) exercises.
After an overview of Qt and its tools, a Hello World application quickly demonstrates the basic principles.
Qt is mainly famous for its intelligent concepts of signals and slots, which is explained together with examples for how to use widgets (UI controls).
At the end, the foundations of the meta-object system and its implications on memory management are explained.
This module follows up the introduction in the "Software Development with Qt" module, plus the Quickstart slides.
Software Development Best Practices: Separating UI from Business LogicICS
One of the most effective software engineering approaches involves separating the user interface (frontend) from the business logic (backend), especially when it comes to developing embedded-devices. This practice makes it far easier to code for a single specific functionality versus coding an overall product.
In this webinar we’ll explain not only what’s involved in separating the UI from business logic in your next Qt project, but explore some of the key benefits of this approach, including:
Parallel development
Modularity
Enhanced testability
Accelerated development
Architecture that easily accommodates future changes
We’ll also touch on a few of the drawbacks, chief among them the need to implement new strategies for independent testing, build and deployment — tasks that take extra time and resources
In today’s economy, internationalization is increasingly important as our target audience has gone from being a local one to a global one. This webinar will look at what tools Qt provides for this task and cover best practices for C++ and QML, as well as the other steps you need to take to create a properly localized Qt application.
Qt Application Programming with C++ is one of the best Qt QML training and courses in Bangalore India. This workshop is ideal for anyone who want to get started with developing GUI Application using Qt framework. Starting with basics, this workshop covers developing multi-threaded, multimedia and 2D graphics based applications with multiple Do-It-Yourself (DIY) exercises.
After an overview of Qt and its tools, a Hello World application quickly demonstrates the basic principles.
Qt is mainly famous for its intelligent concepts of signals and slots, which is explained together with examples for how to use widgets (UI controls).
At the end, the foundations of the meta-object system and its implications on memory management are explained.
This module follows up the introduction in the "Software Development with Qt" module, plus the Quickstart slides.
Software Development Best Practices: Separating UI from Business LogicICS
One of the most effective software engineering approaches involves separating the user interface (frontend) from the business logic (backend), especially when it comes to developing embedded-devices. This practice makes it far easier to code for a single specific functionality versus coding an overall product.
In this webinar we’ll explain not only what’s involved in separating the UI from business logic in your next Qt project, but explore some of the key benefits of this approach, including:
Parallel development
Modularity
Enhanced testability
Accelerated development
Architecture that easily accommodates future changes
We’ll also touch on a few of the drawbacks, chief among them the need to implement new strategies for independent testing, build and deployment — tasks that take extra time and resources
In today’s economy, internationalization is increasingly important as our target audience has gone from being a local one to a global one. This webinar will look at what tools Qt provides for this task and cover best practices for C++ and QML, as well as the other steps you need to take to create a properly localized Qt application.
Graphics View becomes one of the prominent features of Qt these days, it also serves as the backbone for next-generation user-interface developments. This talk highlights several tips and tricks which you can employ to beautify your Graphics View-based application, in order to have much more exciting and interesting user interactions. In addition, a new addition in Qt 4.6, namely the graphics effect feature, will be introduced and demonstrated.
Presentation by Ariya Hidayat held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
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
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 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
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
Qt in depth - presentation for Symbian expo 2009Nokia
Comprehensive presentation about Qt with special focus on Symbian. Close to a training material so if you wanna know what Qt is, have a look at the ~150 slides.
Held in www.see2009.org/ 27.10.2009
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 makes it really easy to write Hybrid applications: Native wrapper + HTML5/JavaScript.
This keynote covers why and how you should use Qt to write hybrid applications.
Visit me at http://ynonperek.com for more info
For the full video of this presentation, please visit:
http://www.embedded-vision.com/platinum-members/luxoft/embedded-vision-training/videos/pages/may-2016-embedded-vision-summit
For more information about embedded vision, please visit:
http://www.embedded-vision.com
Alexey Rybakov, Senior Director at LUXOFT, presents the "Making Computer Vision Software Run Fast on Your Embedded Platform" tutorial at the May 2016 Embedded Vision Summit.
Many computer vision algorithms perform well on desktop class systems, but struggle on resource constrained embedded platforms. This how-to talk provides a comprehensive overview of various optimization methods that make vision software run fast on low power, small footprint hardware that is widely used in automotive, surveillance, and mobile devices. The presentation explores practical aspects of deep algorithm and software optimization such as thinning of input data, using dynamic regions of interest, mastering data pipelines and memory access, overcoming compiler inefficiencies, and more.
Graphics View becomes one of the prominent features of Qt these days, it also serves as the backbone for next-generation user-interface developments. This talk highlights several tips and tricks which you can employ to beautify your Graphics View-based application, in order to have much more exciting and interesting user interactions. In addition, a new addition in Qt 4.6, namely the graphics effect feature, will be introduced and demonstrated.
Presentation by Ariya Hidayat held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
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
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 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
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
Qt in depth - presentation for Symbian expo 2009Nokia
Comprehensive presentation about Qt with special focus on Symbian. Close to a training material so if you wanna know what Qt is, have a look at the ~150 slides.
Held in www.see2009.org/ 27.10.2009
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 makes it really easy to write Hybrid applications: Native wrapper + HTML5/JavaScript.
This keynote covers why and how you should use Qt to write hybrid applications.
Visit me at http://ynonperek.com for more info
For the full video of this presentation, please visit:
http://www.embedded-vision.com/platinum-members/luxoft/embedded-vision-training/videos/pages/may-2016-embedded-vision-summit
For more information about embedded vision, please visit:
http://www.embedded-vision.com
Alexey Rybakov, Senior Director at LUXOFT, presents the "Making Computer Vision Software Run Fast on Your Embedded Platform" tutorial at the May 2016 Embedded Vision Summit.
Many computer vision algorithms perform well on desktop class systems, but struggle on resource constrained embedded platforms. This how-to talk provides a comprehensive overview of various optimization methods that make vision software run fast on low power, small footprint hardware that is widely used in automotive, surveillance, and mobile devices. The presentation explores practical aspects of deep algorithm and software optimization such as thinning of input data, using dynamic regions of interest, mastering data pipelines and memory access, overcoming compiler inefficiencies, and more.
For this info-packed and hands-on workshop we cover:
📍 Introduction to Kubernetes & GitOps talk:
We cover the most popular path that has brought success to many users already - GitOps as a natural evolution of Kubernetes. We'll give an overview of how you can benefit from Kubernetes and GitOps: greater security, reliability, velocity and more. Importantly, we cover definitions and principles standardized by the CNCF's OpenGitOps group and what it means for you.
📍 Get Started with GitOps:
You'll have GitOps up and running in about 30 mins using our free and open source tools! We'll give a brief vision of where you want to be with those security, reliability, and velocity benefits, and then we'll support you while go through the getting started steps. During the workshop, you'll also experience in action and see demos for:
- an opinionated repo structure to minimize decision fatigue
- disaster recovery using GitOps
- Helm charts example
- Multi-cluster example
- all with free and open source tools mostly in the CNCF (eg. Flux and Helm).
If you have questions before or after the workshop, talk to us at #weave-gitops http://bit.ly/WeaveGitOpsSlack (If you need to invite yourself to the Slack, visit https://slack.weave.works/)
For the past 7 years, Midland Valley as been capitalizing on Qt to create advanced geological modeling applications for the Oil & Gas industry. Featuring 2D and 3D modeling and visualization, these applications provide enhanced user interface and easy to use workflows. Combining many Qt technologies in the applications and in our development process (from sockets and widgets to graphics views, models/views, Webkit, designer plug ins, unit tests) has enabled us to deliver superior applications with a better mixed-platform integration, a shorter release cycle, and improved quality.
Presentation by Mike Krus and Colin Dunlop held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Free GitOps Workshop + Intro to Kubernetes & GitOpsWeaveworks
Follow along in this free workshop and experience GitOps!
AGENDA:
Welcome - Tamao Nakahara, Head of DX (Weaveworks)
Introduction to Kubernetes & GitOps - Mark Emeis, Principal Engineer (Weaveworks)
Weave Gitops Overview - Tamao Nakahara
Free Gitops Workshop - David Harris, Product Manager (Weaveworks)
If you're new to Kubernetes and GitOps, we'll give you a brief introduction to both and how GitOps is the natural evolution of Kubernetes.
Weave GitOps Core is a continuous delivery product to run apps in any Kubernetes. It is free and open source, and you can get started today!
https://www.weave.works/product/gitops-core
If you’re stuck, also come talk to us at our Slack channel! #weave-gitops http://bit.ly/WeaveGitOpsSlack (If you need to invite yourself to the Slack, visit https://slack.weave.works/)
Symbio, a leading software foundry, provides software product engineering and R&D co-creation services to the world's technology innovators. With offices in Finland, Sweden, USA and China, Symbio serves such world-leading companies like China Mobile, Google, Nokia, PayPal and ST-Ericsson. www.symbio.com.
ScicomP 2015 presentation discussing best practices for debugging CUDA and OpenACC applications with a case study on our collaboration with LLNL to bring debugging to the OpenPOWER stack and OMPT.
Join this info-packed and hands-on workshop where we will cover:
Introduction to Kubernetes & GitOps talk:
We'll cover the most popular path that has brought success to many users already - GitOps as a natural evolution of Kubernetes. We'll give an overview of how you can benefit from Kubernetes and GitOps: greater security, reliability, velocity and more. Importantly, we cover definitions and principles standardized by the CNCF's OpenGitOps group and what it means for you.
Get Started with GitOps:
You'll have GitOps up and running in about 30 mins using our free and open source tools! We'll give a brief vision of where you want to be with those security, reliability, and velocity benefits, and then we'll support you while go through the getting started steps. During the workshop, you'll also experience in action and see demos for:
* an opinionated repo structure to minimize decision fatigue
* disaster recovery using GitOps
* Helm charts example
* Multi-cluster example
* all with free and open source tools mostly in the CNCF (eg. Flux and Helm).
If you have questions before or after the workshop, talk to us at #weave-gitops http://bit.ly/WeaveGitOpsSlack (If you need to invite yourself to the Slack, visit https://slack.weave.works/)
At Criteo we are using both .NET CLR runtime and JVM one. At first look it seems there are very similar: a bytecode, a JIT, a GC, … but in fact there is some differences in the implementation and in the vision of the targeted applications and their requirements
Let’s dig into those differences with the pros & cons
Title: Sista: Improving Cog’s JIT performance
Speaker: Clément Béra
Thu, August 21, 9:45am – 10:30am
Video Part1
https://www.youtube.com/watch?v=X4E_FoLysJg
Video Part2
https://www.youtube.com/watch?v=gZOk3qojoVE
Description
Abstract: Although recent improvements of the Cog VM performance made it one of the fastest available Smalltalk virtual machine, the overhead compared to optimized C code remains important. Efficient industrial object oriented virtual machine, such as Javascript V8's engine for Google Chrome and Oracle Java Hotspot can reach on many benchs the performance of optimized C code thanks to adaptive optimizations performed their JIT compilers. The VM becomes then cleverer, and after executing numerous times the same portion of codes, it stops the code execution, looks at what it is doing and recompiles critical portion of codes in code faster to run based on the current environment and previous executions.
Bio: Clément Béra and Eliot Miranda has been working together on Cog's JIT performance for the last year. Clément Béra is a young engineer and has been working in the Pharo team for the past two years. Eliot Miranda is a Smalltalk VM expert who, among others, has implemented Cog's JIT and the Spur Memory Manager for Cog.
Performance Benchmarking: Tips, Tricks, and Lessons LearnedTim Callaghan
Presentation covering 25 years worth of lessons learned while performance benchmarking applications and databases. Presented at Percona Live London in November 2014.
Similar to Optimizing Performance in Qt-Based Applications (20)
Introduction to Qt cross-platform application and UI framework. Explaining what Qt does, some historical background, hybrid Internet Applications with Qt Webkit and the future with Qt Quick.
KDE Plasma in your pocket.
Presentation by Alexis Menard held during Bossa Conference 2010 in Manaus.
Read more at http://labs.trolltech.com/blogs/2010/02/28/tokamak-4-the-kde-plasma-meeting/
http://qt.nokia.com
http://www.bossaconference.indt.org/
Shipping Mobile Applications Using Qt for Symbianaccount inactive
Presentation by Espen Riskedal held during Bossa Conference 2010 in Manaus.
Read more at http://labs.trolltech.com/blogs/2010/03/08/hi-from-bossa-conference-and-bossatetrix/
http://qt.nokia.com
http://www.bossaconference.indt.org/
Presentation by Marius Bugge Monsen held during Bossa Conference 2010 in Manaus.
Read more at http://labs.trolltech.com
http://qt.nokia.com
http://www.bossaconference.indt.org/
The Qt Script module enables you as a Qt/C++ application developer to seamlessly integrate scripting into your application, providing script authors with an interface for working in the context of your particular Qt application. The Qt Script language is very similar to JavaScript, so many developers and designers should already find it familiar. This session gives an overview of the main steps of embedding Qt Script into an application, and covers some typical patterns of usage.
Presentation by Kent Hansen held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
The Qt WebKit Integration provides a powerful framework to seamlessly integrate web technologies into applications, where web content can interact with Qt components. This presentation introduces the QtWebKit APIs, the underlying engine and new features coming in future releases.
Presentation by Kenneth Christiansen held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Do you consider yourself a Qt expert, but want to learn how to turbo-charge your programming efficiency while using Qt? Join this session and learn from Qt gurus the tips and tricks you need to get the most out of Qt, get more done in less time and generally look better than your co-workers.
Presentation by Mirko Boehm and Till Adam resp. Romain Pokrzywka held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
This talk is an introduction to development of Qt applications for embedded devices running Windows CE. We will show how to build Qt for your device and you will learn how to create your Qt programs on Desktop Windows and cross-compile it for the target device.
Presentation by Jörg Bornemann held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Supporting several languages is a key point to increase the audience of an application. We will see what is needed in Qt to enable internationalization and how to ensure all the components can be translated. We will also see the tools available for the translators and how to use them.
Presentation by Benjamin Poulain held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Are you developing cross-platform applications with Qt, but are missing a cross-platform development environment? Qt Creator is the answer! Get an introduction to the new Qt Creator cross-platform IDE, see the major features in action and learn how to use Qt Creator to code, debug, build and run Qt apps across platforms.
Presentation by Erik Verbruggen held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
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
The long awaited port of Qt to the Symbian platform is set to be delivered later this year. In addition to being able to target a new platform, application developers will now be able to take advantage of new functionality in Qt to ensure their application integrates seamlessly with the underlying mobile operating system. This session features a brief introduction to the Symbian/S60 platform with a focus on mobile application development using Qt for the Symbian platform.
Presentation by Alessandro Portale held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Modern applications are more and more moving away from static forms. In a modern interface, widgets and graphical elements are animated and transitioned smoothly. Those effects make your application look good but their main purpose should be to help end-users find out what's going on in their applications. In upcoming Qt versions we’re adding a new Animation Framework that relies upon Qt’s QObject-based architecture.
Presentation by Thierry Bastian held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
With the introduction of multi-touch and gesture support coming in Qt, application developers now have the possibility of introducing new types of input and interaction to their applications. We will examine the various types of devices that one can expect to encounter in the multi-touch and gesture "world". This presentation will also introduce and explain the new API, walk through some example code, and show some demos of some of the possibilities we foresee with this technology.
Presentation by Jens Bache-Wiig held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Debugging Qt, Fixing and Contributing a Bug Report (Using Gitorious)account inactive
With Qt's new open contribution model and the Qt source code repositories open on qt.gitorious.org, contributing your code to Qt is easier than ever before. Learn how to take advantage of this new opportunity by walking through the example of debugging and submitting a bugfix using Gitorious.
Presentation by Simon Hausmann held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
The Qt Mobility project is developing new Qt APIs. These APIs will benefit all Qt developers. This presentation shall provide an overview of the APIs and demonstrate the use of some the APIs through an example application. This presentation shall fuel ideas for usage of the new APIs in your own projects.
Presentation by Alex Luddy held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
Weather service, maps and navigation, photo viewer, instant messaging, web browser, flick list or kinetic scrolling. You want all these with Qt? You get it!
Presentation by Ariya Hidayat held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
The Qt Kinetic project is an initiative to provide powerful frameworks to create dynamic, beautiful graphical user interfaces in Qt. As an extension of this effort, the next generation of Qt's item views framework is being designed with animated user interfaces in mind. This talk will give an introduction to the Item Views NG project and the new architecture that is being proposed.
Presentation by Marius Bugge Monsen held during Qt Developer Days 2009.
http://qt.nokia.com/developer/learning/elearning
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
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.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using Deplo...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
2. Introduction
• Bjørn Erik Nilsen
– Software Engineer / Qt Widget Team
– The architect behind Alien Widgets
– Rewrote the Backing Store for Qt 4.5
– One of the guys implementing
WidgetsOnGraphicsView
– Author of QMdiArea/QMdiSubWindow
– Author of QGraphicsEffect/QGraphicsEffectSource
2
3. Agenda
• Why Performance Matters
• Performance Improvements in Qt 4.6
• How You Can Improve Performance
3
4. Why Performance Matters
• Attractive to users
• Looks more professional
• Help you get things done more efficiently
• Keeps the flow
4
6. Why Performance Matters
• Performance is more important than ever before
– Dynamic user interfaces
• Qt Everywhere
– Desktop
– Embedded platforms with limited hardware
• We cannot just buy better hardware anymore
• Clock speed vs. number of cores
6
7. Why Performance Matters
• Not all applications can take advantage of
multiple cores
• And some will actually run slower:
– Each core in the processor is slower
– Most applications not programmed to be multi-
threaded
• Multi-core crisis?
7
8. Agenda
• Why Performance Matters
• Performance Improvements in Qt 4.6
• How You Can Improve Performance
8
9. Performance Improvements in Qt 4.6
• We continuously strive to optimize the performance
– QWidget painting performance, for example:
– Qt 4.6 no exception!
9
11. Performance Improvements in Qt 4.6
• Graphics View
– New update mechanism QtGui
– New painting algorithm
– New scene indexing
– Reduced QTransform/QVariant/floating point
overhead
• QPixmapCache
– Extended with an int based API
11
12. Performance Improvements in Qt 4.6
• Item Views
– Item selection QtGui
– Drag 'n' drop
– QTableView and QHeaderView
• QTransform
– fromTranslate/fromScale
– mapRect for projective transforms
• QRegion
– No longer a GDI object on Windows
12
13. Performance Improvements in Qt 4.6
• QObject
– Destruction QtCore
– Connect and disconnect
– Signal emission
• QVariant
– Construction from float and pointers
• QIODevice
– Less (re)allocations in readAll()
13
14. Performance Improvements in Qt 4.6
• QNetworkAccessManager
– HTTP back-end QtNetwork
• QHttpNetworkConnectionChannel
– Pipelining HTTP requests (off by default)
• QHttpNetworkConnection
– Increased the number of concurrent connections
• QLocalSocket
– New Windows implementation
– Major performance improvements
14
15. Performance Improvements in Qt 4.6
QtScript
• QtScript now uses JavaScriptCore as the back-end!
– Still the same API, but with JSC performance
15
16. Performance Improvements in Qt 4.6
• New OpenGL 2.x paint engine
• General improvements QtOpenGL
– Clipping
– Text drawing
16
17. Performance Improvements in Qt 4.6
• New OpenVG paint engine New module!
– Uses Khronos EGL API QtOpenVG
– Configure Qt with “-openvg”
• Support for hardware-accelerated 2D vector graphics on:
– Embedded, mobile and consumer electronic devices
– Desktop
• More info: http://labs.trolltech.com/blogs
17
18. Performance Improvements in Qt 4.6
Embedded
• Improved support for DirectFB
– Enabling hardware graphics acceleration on
embedded platforms
• Maemo Harmattan optimizations
18
19. Agenda
• Why Performance Matters
• Performance Improvements in Qt 4.6
• How You Can Improve Performance
19
20. How You Can Improve Performance
• Theory of Constraints (TOC) by Eliyahu M. Goldratt
• The theory is based on the idea that in any complex
system, there is usually one aspect of that system that
limits its ability to achieve its goal or optimal
functioning. To achieve any significant improvement of
the system, the constraint must be identified and
resolved.
• Applications will perform as fast as their bottlenecks
20
21. Theory of Constraints
• Define a goal:
– For example: This application must run at 30 FPS
• Then:
1) Identify the constraint
2) Decide how to exploit the constraint
3) Improve
4) If goal not reached, go back to 1)
5) Done
21
22. Identifying hot spots (1)
• The number one and most important task
• Make sure you have plausible data
• Don't randomly start looking for slow code paths!
– An O(n2) algorithm isn't necessarily bad
– Don't spend time on making it O(n log n) just for fun
• Don't spend time on optimizing bubble sort
22
23. Identifying hot spots (1)
• “Bottlenecks occur in
surprising places, so
don't try second guess
and put in a speed hack
until you have proven
that is where the
bottleneck is” -- Rob Pike
23
24. Identifying hot spots (1)
• The right approach for identifying hot spots:
– Any profiler suitable for your platform
• Shark (Mac OSX)
• Valgrind (X11)
• Visual Studio Profiler (Windows)
• Embedded Trace Macrocell (ETM) (ARM devices)
• NB! Always profile in release mode
24
25. Identifying hot spots (1)
• Run application: “valgrind --tool=callgrind ./application”
• This will collect data and information about the program
• Data saved to file: callgrind.out.<pid>
• Beware:
– I/O costs won't show up
– Cache misses (--simulate-cache=yes)
• The next step is to analyze the data/profile
• Example
25
26. Identifying hot spots (1)
• Profiling a section of code (run with “–instr-atstart=no”):
#include<BbrValgrind/callgrind.h>
int myFunction() const
{
CALLGRIND_START_INSTRUMENTATION;
int number = 10;
...
CALLGRIND_STOP_INSTRUMENTATION;
CALLGRIND_DUMP_STATS;
return number;
}
26
27. Identifying hot spots (1)
• When a hot-spot is identified:
– Look at the code and ask yourself: Is this the right
algorithm for this task?
• Once the best algorithm is selected, you can exploit the
constraint
27
28. How to exploit the constraint (2)
• Optimize
– Design level
– Source code level
– Compile level
• Optimization trade-offs:
– Memory consumption, cache misses
– Code clarity and conciseness
28
29. How to exploit the constraint (2)
• “Any intelligent fool can
make things bigger,
more complex, and more
violent. It takes a touch
of genius – and a lot of
courage – to move in the
opposite direction.”
--Einstein
29
30. How to exploit the constraint (2)
• Wouldn't it be great to have a cross-platform tool to
measure performance?
30
31. QTestLib
• Say hello to QBENCHMARK
• Extension to the QTestLib framework
• Cross-platform
• Straight forward: QBENCHMARK { <code here> }
• Code will then be measured based on
– Walltime (default)
– CPU tick counter (-tickcounter)
– Valgrind/Callgrind (-callgrind)
– Event counter (-eventcounter)
31
32. QTestLib
• Let's create a benchmark
• Run with ./mytest -xml -o results.xml
• git clone git://gitorious.org/qt-labs/qtestlib-tools.git
• Visualize with
– Graph (generatereport results.xml)
– BMCompare (bmcompare results1.xml results2.xml)
• Now that we have tool, it is easier to measure and
decide which algorithm to use
32
33. How to exploit the constraint (2)
• General tricks:
– Caching
– Delay a computation until the result is required
– Reduce computation in tight loops
– Compiler optimizations
• Optimization Techniques for Qt:
– Choose the right container
– Use implicit data sharing efficiently
– Discover the magic flags
33
34. Implicit data sharing in Qt
• Maximize resource usage and minimize copying
Object obj0; // Creates ObjectData
// Copies (share the same data)
Object obj1, obj2, obj3 = obj0;
Object 1
Object 0 ObjectData Object 2
Object 3
Shallow copies
34
35. Implicit data sharing in Qt
• Data is only copied if someone modifies it:
Deep copy
ObjectData Object 1
Object 0 ObjectData Object 2
Object 3
Shallow copies
35
36. Implicit data sharing in Qt
• How to avoid deep-copy:
– Only use const operators and functions if possible
– Be careful with the foreach keyword
• For classes that are not implicitly shared:
– Always pass them around as const references
– Passing const references is a good habit in any case
• Examples
36
37. Implicit data sharing in Qt
Original Optimized
T *readOnly = list[index]; T *readOnly = list.at(index);
QList<T>::iterator i; QList<T>::const_iterator i;
i = list.begin(); i = list.constBegin();
foreach (QString s, strings) foreach (const QString &s, strings)
NB! QTransform is not implicitly shared!
void foo(QTransform t); void foo(const QTransform &t);
37
38. Implicit data sharing in Qt
• See the “Implicitly Shared Classes” documentation for a
complete list of implicitly shared classes in Qt
• http://doc.trolltech.com/4.6-snapshot/shared.html
• Note: All Qt containers are implicitly shared
38
43. QVector<T>
• Items are stored contiguously in memory
• One block of memory is allocated:
QBasicAtomicInt int int uint T T
ref alloc size flags array[0] ... array[alloc - 1]
QVectorTypedData<T>
d
QVector<T>
43
44. QVector<T>
• Reserves space at the end
• Growth strategy depends on the type T
– Movable types: realloc by increments of 4096 bytes
– Non-movable types: 50% increments
• What is a movable type?
– Primitive types: bool, int, char, enums, pointers, …
– Plain Old Data (POD) with no constructor/destructor
– Basically everything that can be moved around in
memory using memcpy() or memmove()
– Good article: http://www.ddj.com/cpp/184401508
44
45. Movable types
• User-defined classes are treated as non-movable by
default
• Oh no!
• Have no fear, Q_DECLARE_TYPEINFO is here
• You can tell Qt that your class is a:
– Q_PRIMITIVE_TYPE: POD with no constr./destr.
– Q_MOVABLE_TYPE: has constr./destr., but can be
moved in memory using memcpy()/memmove()
45
49. QList<T>
• Two representations
• Array of pointers to items on the heap (general case)
QBasicAtomicInt int int int uint void * void *
ref alloc begin end flags array[0] ... array[alloc - 1]
QListData::Data
T T
d
QList<T>
49
50. QList<T>
• Special case: T is movable and sizeof(T) <= sizeof(void *)
• Items are stored directly (same as QVector)
QBasicAtomicInt int int int uint T T
ref alloc begin end flags array[0] ... array[alloc - 1]
QListData::Data
d
QList<T>
50
51. QList<T>
• Reserves space at the beginning and at the end
• Benefits of reserving space at the beginning
– Prepending an item usually takes constant time
– Removing the first item usually takes constant time
– Faster insertion
51
52. QVector<T> vs. QList<T>
• QList expands to less code in the executable
• For most purposes, QList is the right class to use
• If all you do is append(), use QVector
– Use reserve() if you know the size in advance
– Also consider QVarLengthArray or plain C array
• When T is movable and sizeof(T) <= sizeof(void *)
– Almost no difference, except that QList provides faster
insertions/removals in the first half of the list
• (Constant time insertions in the middle: Use QLinkedList)
52
53. General Qt Container Advices
• Avoid deep copies, e.g:
– Use at() rather than operator[]
– constData()/constBegin()/constEnd()
– Basically: limit usage of non-const functions
• When you know the size in advance:
– Use reserve()
• Let Qt know whether your class is movable or not
– Q_DECLARE_TYPEINFO
• Choose the right container for the right circumstance
53
54. General Painting Optimizations
• Prefer QPixmap over QImage (if possible)
– QPixmap is accelerated
– QPixmap caches information about the pixels
• Avoid QPixmap/QImage::setAlphaChannel()
– Use QPainter::setCompositionMode instead
• Avoid QPixmap/QImage::transformed()
– Use QPainter::setWorldTransform instead
• If you for sure know the image has alpha:
– Qt::NoOpaqueDetection (QPixmap::fromImage)
54
55. General Painting Optimizations
Original
int width = image.width();
int height = image.height();
for (int y = 0; y < height; ++y) {
for (int x = 0; x < width; ++x) {
QRgb pixel = image.pixel(x, y);
…
}
}
NB! Image is 32 bit
55
56. General Painting Optimizations
Optimized
int width = image.width();
int height = image.height();
for (int y = 0; y < height; ++y) {
QRgb *line = reinterpret_cast<QRgb *>(image.scanLine(y));
for (int x = 0; x < width; ++x) {
QRgb pixel = line[x];
…
}
}
56
57. General Painting Optimizations
Even more optimized
int numPixels = image.width() * image.height();
QRgb *pixels = reinterpret_cast<QRgb *>(image.bits());
for (int i = 0; i < numPixels; ++i) {
QRgb pixel = pixels[i];
…
}
}
57
61. Other Optimizations
Original Optimized
qFuzzyCompare(opacity+1, 1)); qFuzzyIsNull(opacity));
int nRects = qregion.rects().size(); int nRects = qregion.numRects();
if (expensive() && cheap()) if (cheap() && expensive())
#button1 { background:red } #button1,
#button2 { background:red } #button2 { background:red }
*[readOnly=”1”] { color:blue } /* Only QLineEdit can possibly be
read-only in my application
*/
QLineEdit[readOnly = “1”]
{ color:blue }
61
62. Graphics View Optimizations
• Viewport update modes
• Scene index
– BSP tree index
– No index
• Avoid QGraphicsScene::changed signal
• QGraphicsScene::setSceneRect
• Cache modes
– Device coordinates
– Item coordinates
• OpenGL viewport
62
63. Platform Specific Optimizations
• Link time optimization LTCG (Windows only)
– Approx. 10%-15% speedup
– Configure Qt with “-ltcg”
• Don't use explicit double arithmetic
– qreal is float on embedded (QWS)
– 100 / 2.54 → 100 / qreal(2.54)
• It's time time to take advantage of what we have
learned
• Let's do some real optimizations!
63
64.
65. Theory of Constraints
• Define a goal:
– For example: This application must run at 30 FPS
• Then:
1) Identify the constraint
2) Decide how to exploit the constraint
3) Improve
4) If goal not reached, go back to 1)
5) Done
65
66. Agenda
• Why Performance Matters
• Performance Improvements in Qt 4.6
• How You Can Improve Performance
66