The document discusses the new features in C++11 including new language features such as rvalue references, decltype, lambdas, and auto; new library features such as smart pointers, regular expressions, and hash tables; and the status of support for C++11 in Visual Studio 2010 and 2012. It also discusses modern C++ style using features like lambdas, smart pointers, and move semantics.
A minimal collection of most wanted and widely accepted idioms and coding conventions for C++ development presented with examples and explanations. The lecture targets performance oriented codes so emphasis is on performance-friendly techiques.
Topics covered:
1) Design issues: idioms and best practices
- Resource Aquisition Is Initialization (RAII)
- Ownership semantics and smart pointers
- Header files: dependencies and decoupling
2) Objects Construction/Destruction/Copying
- Designing constructors
- Rule Of Three
- Transactional programming
3) Namespaces
- ADL/Koenig Lookup
4) Static analyzers
[C++] The Curiously Recurring Template Pattern: Static Polymorphsim and Expre...Francesco Casalegno
••• Exploit the full potential of the CRTP! •••
In this presentation you will learn:
▸ what is the curiously recurring template pattern
▸ the actual cost (memory and time) of virtual functions
▸ how to implement static polymorphism
▸ how to implement expression templates to avoid loops and copies
A minimal collection of most wanted and widely accepted idioms and coding conventions for C++ development presented with examples and explanations. The lecture targets performance oriented codes so emphasis is on performance-friendly techiques.
Topics covered:
1) Design issues: idioms and best practices
- Resource Aquisition Is Initialization (RAII)
- Ownership semantics and smart pointers
- Header files: dependencies and decoupling
2) Objects Construction/Destruction/Copying
- Designing constructors
- Rule Of Three
- Transactional programming
3) Namespaces
- ADL/Koenig Lookup
4) Static analyzers
[C++] The Curiously Recurring Template Pattern: Static Polymorphsim and Expre...Francesco Casalegno
••• Exploit the full potential of the CRTP! •••
In this presentation you will learn:
▸ what is the curiously recurring template pattern
▸ the actual cost (memory and time) of virtual functions
▸ how to implement static polymorphism
▸ how to implement expression templates to avoid loops and copies
C++11 Idioms @ Silicon Valley Code Camp 2012 Sumant Tambe
C++11 feels like a new language. Compared to its previous standards, C++11 packs more language features and libraries designed to make C++ programs easier to understand and faster. As the community is building up experience with the new features, new stylistic ways of using them are emerging. These styles (a.k.a. idioms) give the new language its unique flavor. This talk will present emerging idioms of using rvalue references -- a marquee feature of C++11 as many renowned experts call it. You will see how C++11 opens new possibilities to design class interfaces. Finally, you will learn some advanced use-cases of rvalue references which will likely make you feel something amiss in this flagship feature of C++11.
••• Boost your code's performances using C++11 new features! •••
In this presentation you will learn:
▸ the difference between an Lvalue and Rvalue
▸ how to use std::move, std::forward, noexcept
▸ how to implement move semantics to avoid useless copies
▸ how to implement perfect forwarding for the factory pattern
Presentation with a brief history of C, C++ and their ancestors along with an introduction to latest version C++11 and futures such as C++17. The presentation covers applications that use C++, C++11 compilers such as LLVM/Clang, some of the new language features in C++11 and C++17 and examples of modern idioms such as the new form compressions, initializer lists, lambdas, compile time type identification, improved memory management and improved standard library (threads, math, random, chrono, etc). (less == more) || (more == more)
It's not your mother's C++ anymore. Manual memory management, tedious loops, difficult-to-use STL algorithms -- are all a thing of the past now. The new C++ 11 standard contains a huge number of improvements to the C++ core language and standard library, and can help C++ developers be more productive.
In this session we will discuss the major features of C++ 11, including lambda functions, type inference for local variables, range-based for loops, smart pointers, and more. We will see how to use these features effectively to modernize your existing C++ programs and how to develop in the modern C++ style.
••• Learn how to safely manage memory with smart pointers! •••
In this presentation you will learn:
▸ the dangers of using raw pointers for dynamic memory
▸ the difference between unique_ptr, shared_ptr, weak_ptr
▸ how to use factories to increase safety and performance
▸ when raw pointers are still needed
Slides from my "Gentle Introduction to Modern C++" presentation from January 20, 2015 at the Dublin C/C++ User Group: www.meetup.com/cppdug/events/219787667/
The code examples are located here: https://github.com/mihaitodor/Presentations/tree/master/cppdug/20.01.2015
The presentation shows major features of the new C++ standard (language and the library). The full list of new things is very broad, so I've categorized them to be easier to understand.
An introductory PowerPoint to understanding and applying the C++ programming language. Broken down into lessons covering:
Introduction: Definitions and the History of Programming
Lesson 1: Libraries, Variables and Types, Blocks and Namespaces, Functions
Lesson 2: If...Else Statements, For and While Loops, Scope
Exercise: Program a Gumball Game
Lesson 3: Classes and Objects, Pointers
Oh Crap, I Forgot (Or Never Learned) C! [CodeMash 2010]Chris Adamson
Abstract: Chances are you code in a language that's either descended from C, inspired by C, or run in an interpreter that itself is written in C. Still... do you actually know how to code in C? Despite its long-standing position as a sort of "lingua franca", an agreed-upon common language, more and more developers are putting together successful, satisfying careers, without ever learning this seminal language. But what if you have to call into C code from your favorite scripting language, or use APIs like OpenGL that are written to be called from C? Many developers find C very challenging, particularly its manual memory-management and other low-level concerns. In this session, we'll show you why you shouldn't be afraid of C, how you can use the skills you already have from the languages you code in today, and how to master structs, enums, typedefs, malloc(), free(), and the rest of C's sharp edges. Examples will be from the point-of-view of the C-skewing iPhone SDK, but will be designed to be broadly applicable and platform-agnostic.
Fun with Lambdas: C++14 Style (part 1)Sumant Tambe
If virtual functions in C++ imply design patterns, then C++ lambdas imply what? What does it really mean to have lambdas in C++? Frankly, I don't know but I've a hunch: It's BIG.
Just like virtual functions open doors to the OO paradigm, lambdas open doors to a different paradigm--the functional paradigm. This talk is not a praise of functional programming or some elusive lambda-based library. (Although, I'll mention one briefly that tops my list these days.) Instead, the goal is to have fun while working our way through some mind-bending examples of C++14 lambdas. Beware, your brain will hurt! Bring your laptop and code the examples right along because that may be the fastest way to answer the quiz.
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
C++11 Idioms @ Silicon Valley Code Camp 2012 Sumant Tambe
C++11 feels like a new language. Compared to its previous standards, C++11 packs more language features and libraries designed to make C++ programs easier to understand and faster. As the community is building up experience with the new features, new stylistic ways of using them are emerging. These styles (a.k.a. idioms) give the new language its unique flavor. This talk will present emerging idioms of using rvalue references -- a marquee feature of C++11 as many renowned experts call it. You will see how C++11 opens new possibilities to design class interfaces. Finally, you will learn some advanced use-cases of rvalue references which will likely make you feel something amiss in this flagship feature of C++11.
••• Boost your code's performances using C++11 new features! •••
In this presentation you will learn:
▸ the difference between an Lvalue and Rvalue
▸ how to use std::move, std::forward, noexcept
▸ how to implement move semantics to avoid useless copies
▸ how to implement perfect forwarding for the factory pattern
Presentation with a brief history of C, C++ and their ancestors along with an introduction to latest version C++11 and futures such as C++17. The presentation covers applications that use C++, C++11 compilers such as LLVM/Clang, some of the new language features in C++11 and C++17 and examples of modern idioms such as the new form compressions, initializer lists, lambdas, compile time type identification, improved memory management and improved standard library (threads, math, random, chrono, etc). (less == more) || (more == more)
It's not your mother's C++ anymore. Manual memory management, tedious loops, difficult-to-use STL algorithms -- are all a thing of the past now. The new C++ 11 standard contains a huge number of improvements to the C++ core language and standard library, and can help C++ developers be more productive.
In this session we will discuss the major features of C++ 11, including lambda functions, type inference for local variables, range-based for loops, smart pointers, and more. We will see how to use these features effectively to modernize your existing C++ programs and how to develop in the modern C++ style.
••• Learn how to safely manage memory with smart pointers! •••
In this presentation you will learn:
▸ the dangers of using raw pointers for dynamic memory
▸ the difference between unique_ptr, shared_ptr, weak_ptr
▸ how to use factories to increase safety and performance
▸ when raw pointers are still needed
Slides from my "Gentle Introduction to Modern C++" presentation from January 20, 2015 at the Dublin C/C++ User Group: www.meetup.com/cppdug/events/219787667/
The code examples are located here: https://github.com/mihaitodor/Presentations/tree/master/cppdug/20.01.2015
The presentation shows major features of the new C++ standard (language and the library). The full list of new things is very broad, so I've categorized them to be easier to understand.
An introductory PowerPoint to understanding and applying the C++ programming language. Broken down into lessons covering:
Introduction: Definitions and the History of Programming
Lesson 1: Libraries, Variables and Types, Blocks and Namespaces, Functions
Lesson 2: If...Else Statements, For and While Loops, Scope
Exercise: Program a Gumball Game
Lesson 3: Classes and Objects, Pointers
Oh Crap, I Forgot (Or Never Learned) C! [CodeMash 2010]Chris Adamson
Abstract: Chances are you code in a language that's either descended from C, inspired by C, or run in an interpreter that itself is written in C. Still... do you actually know how to code in C? Despite its long-standing position as a sort of "lingua franca", an agreed-upon common language, more and more developers are putting together successful, satisfying careers, without ever learning this seminal language. But what if you have to call into C code from your favorite scripting language, or use APIs like OpenGL that are written to be called from C? Many developers find C very challenging, particularly its manual memory-management and other low-level concerns. In this session, we'll show you why you shouldn't be afraid of C, how you can use the skills you already have from the languages you code in today, and how to master structs, enums, typedefs, malloc(), free(), and the rest of C's sharp edges. Examples will be from the point-of-view of the C-skewing iPhone SDK, but will be designed to be broadly applicable and platform-agnostic.
Fun with Lambdas: C++14 Style (part 1)Sumant Tambe
If virtual functions in C++ imply design patterns, then C++ lambdas imply what? What does it really mean to have lambdas in C++? Frankly, I don't know but I've a hunch: It's BIG.
Just like virtual functions open doors to the OO paradigm, lambdas open doors to a different paradigm--the functional paradigm. This talk is not a praise of functional programming or some elusive lambda-based library. (Although, I'll mention one briefly that tops my list these days.) Instead, the goal is to have fun while working our way through some mind-bending examples of C++14 lambdas. Beware, your brain will hurt! Bring your laptop and code the examples right along because that may be the fastest way to answer the quiz.
Improving The Quality of Existing SoftwareSteven Smith
Presented at DevReach 2013.
As developers, most of our time is spent working on existing software. Sure, occasionally we get the chance to fire up a new Solution in Visual Studio, and that can be exciting. But after the first day, we find ourselves once more having to deal with the work we did yesterday. And today, we know more than we did yesterday, so there are things we’d do differently, if we had it to do over.
Over time, software rots. If we’re not diligent, our beautiful code can degrade into a worthless mess. Keeping our code in working condition is no different than changing the oil in our car – it’s preventive maintenance. In this session, Steve will look at some common places to look for signs of degradation in existing applications, and steps to take to improve the code. Examples will use C# and primarily ASP.NET.
Bjarne Stroustrup - The Essence of C++: With Examples in C++84, C++98, C++11,...Complement Verb
C++11 is being deployed and the shape of C++14 is becoming clear. This talk examines the foundations of C++. What is essential? What sets C++ apart from other languages? How do new and old features support (or distract from) design and programming relying on this essence?
I focus on the abstraction mechanisms (as opposed to the mapping to the machine): Classes and templates. Fundamentally, if you understand vector, you understand C++.
Type safety and resource safety are key design aims for a program. These aims must be met without limiting the range of applications and without imposing significant run-time or space overheads. I address issues of resource management (garbage collection is not an ideal answer and pointers should not be used as resource handles), generic programming (we must make it simpler and safer), compile-time computation (how and when?), and type safety (casts belongs in the lowest-level hardware interface). I will touch upon move semantics, exceptions, concepts, type aliases, and more. My aim is not so much to present novel features and technique, but to explore how C++’s feature set supports a new and more effective design and programming style.
An Introduction to Part of C++ STL for OI. Introduced the common use of STL algorithms and containers, especially those are helpful to OI.
Also with some examples.
The presentation discusses software design. It discusses the characteristics of a good and bad design. Then it talks about how to achieve a good design. Then finally we discuss the SOLID Principles of Object Oriented Design. These are 5 principles compiled by Rober Cecil Martin aka Uncle Bob. The benefit of these principles is to achieve a good OO design which is high in cohesion and low in coupling thus easily adaptable to change
Of the SOLID principles, made famous by Robert C. Martin, we'll discuss the Interface Segregation Principle and the Dependency Inversion Principle. This session will explain them thoroughly and give real life examples instead of the regular customer & order examples. You'll walk away knowing what the benefits are and how to use them properly.
Of the SOLID principles, made famous by Robert C. Martin, we'll discuss the Single Responsibility Principle and the Open/Closed Principle, two of the presenter's favorite principles. But at the same time the least understood and used principles. That's why this session will explain them thoroughly and give real life examples instead of the regular customer & order examples. You'll walk away knowing what the benefits are and how to use them properly.
Abstract Base Class and Polymorphism in C++Liju Thomas
Connect with me through Facebook and twitter for more details:http://www.facebook.com/lijuthomas24, http://www.twitter.com/lijuthomas24
This ppt explains the concept of abstract base class and Polymorphism in C++
Keys to Continuous Delivery Success - Mark Warren, Product Director, Perforc...Perforce
Many well-known SaaS vendors use Continuous Delivery to update production sites at mind-bogglingly short intervals and non-SaaS organizations are increasingly looking to CD to increase customer satisfaction and be more competitive.This session will review case studies by Perforce customers, including NYSE, CCP Games, salesforce.com and others, to identify key success factors and provide recommendations for starting, or accelerating, the adoption of CD in your organization.
Whats New in Visual Studio 2012 for C++ DevelopersRainer Stropek
For a Microsoft event we have been hired to do a full-day workshop about news in Visual Studio 2012 for C++ developers. My colleague Philipp Aumayr conducted the workshop. Here are the slides for his talk. More details including sample code can be found in our developer blog at http://www.software-architects.com
Domain-Specific Languages for Composable Editor Plugins (LDTA 2009)lennartkats
Modern IDEs increase developer productivity by incorporating many different kinds of editor services. These can be purely syntactic, such as syntax highlighting, code folding, and an outline for navigation; or they can be based on the language semantics, such as in-line type error reporting and resolving identifier declarations. Building all these services from scratch requires both the extensive knowledge of the sometimes complicated and highly interdependent APIs and extension mechanisms of an IDE framework, and an in-depth understanding of the structure and semantics of the targeted language. This paper describes Spoofax/IMP, a meta-tooling suite that provides high-level domain-specific languages for describing editor services, relieving editor developers from much of the framework-specific programming. Editor services are defined as composable modules of rules coupled to a modular SDF grammar. The composability provided by the SGLR parser and the declaratively defined services allows embedded languages and language extensions to be easily formulated as additional rules extending an existing language definition. The service definitions are used to generate Eclipse editor plugins. We discuss two examples: an editor plugin for WebDSL, a domain-specific language for web applications, and the embedding of WebDSL in Stratego, used for expressing the (static) semantic rules of WebDSL.
- What's new in .NET Platform
- What's new in Visual Studio 2017
- What's new in C# 7.0: out variables, Tuples, Pattern Maching, ref locals and returns, Local Functions, More expression-bodied members, throw Expressions, Generalized async return types, Numeric literal syntax improvements
Code is not text! How graph technologies can help us to understand our code b...Andreas Dewes
Today, we almost exclusively think of code in software projects as a collection of text files. The tools that we use (version control systems, IDEs, code analyzers) also use text as the primary storage format for code. In fact, the belief that “code is text” is so deeply ingrained in our heads that we never question its validity or even become aware of the fact that there are other ways to look at code.
In my talk I will explain why treating code as text is a very bad idea which actively holds back our understanding and creates a range of problems in large software projects. I will then show how we can overcome (some of) these problems by treating and storing code as data, and more specifically as a graph. I will show specific examples of how we can use this approach to improve our understanding of large code bases, increase code quality and automate certain aspects of software development.
Finally, I will outline my personal vision of the future of programming, which is a future where we no longer primarily interact with code bases using simple text editors. I will also give some ideas on how we might get to that future.
O'Reilly Velocity New York 2016 presentation on modern Linux tracing tools and technology. Highlights the available tracing data sources on Linux (ftrace, perf_events, BPF) and demonstrates some tools that can be used to obtain traces, including DebugFS, the perf front-end, and most importantly, the BCC/BPF tool collection.
Imagine you're tackling one of these evasive performance issues in the field, and your go-to monitoring checklist doesn't seem to cut it. There are plenty of suspects, but they are moving around rapidly and you need more logs, more data, more in-depth information to make a diagnosis. Maybe you've heard about DTrace, or even used it, and are yearning for a similar toolkit, which can plug dynamic tracing into a system that wasn't prepared or instrumented in any way.
Hopefully, you won't have to yearn for a lot longer. eBPF (extended Berkeley Packet Filters) is a kernel technology that enables a plethora of diagnostic scenarios by introducing dynamic, safe, low-overhead, efficient programs that run in the context of your live kernel. Sure, BPF programs can attach to sockets; but more interestingly, they can attach to kprobes and uprobes, static kernel tracepoints, and even user-mode static probes. And modern BPF programs have access to a wide set of instructions and data structures, which means you can collect valuable information and analyze it on-the-fly, without spilling it to huge files and reading them from user space.
In this talk, we will introduce BCC, the BPF Compiler Collection, which is an open set of tools and libraries for dynamic tracing on Linux. Some tools are easy and ready to use, such as execsnoop, fileslower, and memleak. Other tools such as trace and argdist require more sophistication and can be used as a Swiss Army knife for a variety of scenarios. We will spend most of the time demonstrating the power of modern dynamic tracing -- from memory leaks to static probes in Ruby, Node, and Java programs, from slow file I/O to monitoring network traffic. Finally, we will discuss building our own tools using the Python and Lua bindings to BCC, and its LLVM backend.
eBPF (extended Berkeley Packet Filters) is a modern kernel technology that can be used to introduce dynamic tracing into a system that wasn't prepared or instrumented in any way. The tracing programs run in the kernel, are guaranteed to never crash or hang your system, and can probe every module and function -- from the kernel to user-space frameworks such as Node and Ruby.
In this workshop, you will experiment with Linux dynamic tracing first-hand. First, you will explore BCC, the BPF Compiler Collection, which is a set of tools and libraries for dynamic tracing. Many of your tracing needs will be answered by BCC, and you will experiment with memory leak analysis, generic function tracing, kernel tracepoints, static tracepoints in user-space programs, and the "baked" tools for file I/O, network, and CPU analysis. You'll be able to choose between working on a set of hands-on labs prepared by the instructors, or trying the tools out on your own test system.
Next, you will hack on some of the bleeding edge tools in the BCC toolkit, and build a couple of simple tools of your own. You'll be able to pick from a curated list of GitHub issues for the BCC project, a set of hands-on labs with known "school solutions", and an open-ended list of problems that need tools for effective analysis. At the end of this workshop, you will be equipped with a toolbox for diagnosing issues in the field, as well as a framework for building your own tools when the generic ones do not suffice.
Swift: Apple's New Programming Language for iOS and OS XSasha Goldshtein
Presentation from Software Architect 2014, covering Swift -- Apple's new programming language for iOS and OS X. The presentation focuses on Swift's language features, which make it so different from mainstream programming languages. Towards the end of the live talk, we also built an iOS app using Swift.
C# Everywhere: Cross-Platform Mobile Apps with XamarinSasha Goldshtein
Presentation from Software Architect 2014, covering Xamarin's offering for building cross-platform mobile applications in C# while using the native platform APIs. The live talk also covered Xamarin.Forms.
Presentation from Software Architect 2014, covering modern cloud backends for mobile apps with a focus on Microsoft Azure Mobile Services and Facebook Parse.
Delivering Millions of Push Notifications in MinutesSasha Goldshtein
Presentation from TechDays Netherlands 2014 on using Azure Notification Hubs to deliver millions of push notifications - through a Mobile Services backend or through an arbitrary backend including Node.js or .NET console apps.
Building Mobile Apps with a Mobile Services .NET BackendSasha Goldshtein
Presentation from TechDays Netherlands 2014 on using the newly announced .NET backend for Azure Mobile Services to build mobile applications, and on using the Offline Sync preview in Windows Store apps.
Presentation from DevWeek 2014 on task and data parallelism. This session explains the TPL APIs and then covers various scenarios for extracting concurrency, reducing synchronization, putting thresholds on parallelization, and other topics.
O'Reilly Fluent 2014 talk on attacking web applications. Showing practical demos of attacking web assets, including XSS, CSRF, insecure cookie placement, traffic manipulation, and other tactics.
Presentation from ConFoo 2014 on Windows Azure Mobile Services. Introducing the platform, building out an application that uses data storage, server-side scripts, custom API endpoints, push notifications, and client authentication. Source code is available on GitHub at http://github.com/goldshtn/rentahome
Presentation from ConFoo 2014 on Android development. Introducing the Android platform, discussing the major components in the ecosystem, and building a basic todo list manager app with Eclipse.
Presentation at ConFoo 2014 on iOS Development. Discussing the basic components of the iOS ecosystem and building a basic todo list manager app with Xcode and storyboards.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
"Impact of front-end architecture on development cost", Viktor TurskyiFwdays
I have heard many times that architecture is not important for the front-end. Also, many times I have seen how developers implement features on the front-end just following the standard rules for a framework and think that this is enough to successfully launch the project, and then the project fails. How to prevent this and what approach to choose? I have launched dozens of complex projects and during the talk we will analyze which approaches have worked for me and which have not.
Connector Corner: Automate dynamic content and events by pushing a buttonDianaGray10
Here is something new! In our next Connector Corner webinar, we will demonstrate how you can use a single workflow to:
Create a campaign using Mailchimp with merge tags/fields
Send an interactive Slack channel message (using buttons)
Have the message received by managers and peers along with a test email for review
But there’s more:
In a second workflow supporting the same use case, you’ll see:
Your campaign sent to target colleagues for approval
If the “Approve” button is clicked, a Jira/Zendesk ticket is created for the marketing design team
But—if the “Reject” button is pushed, colleagues will be alerted via Slack message
Join us to learn more about this new, human-in-the-loop capability, brought to you by Integration Service connectors.
And...
Speakers:
Akshay Agnihotri, Product Manager
Charlie Greenberg, Host
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/
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.
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.
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.
DevOps and Testing slides at DASA ConnectKari Kakkonen
My and Rik Marselis slides at 30.5.2024 DASA Connect conference. We discuss about what is testing, then what is agile testing and finally what is Testing in DevOps. Finally we had lovely workshop with the participants trying to find out different ways to think about quality and testing in different parts of the DevOps infinity loop.
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.
3. • After more than a decade of contemplation . . .
• ISO C++11 Standard was published in September 2011
• Feature list: http://en.wikipedia.org/wiki/C%2B%2B11
• The Standard Library is part of the C++11 standard
• Some new features are upstream merges from TR1
4. • Visual Studio 2010: Some features are supported
• Visual Studio 2012: Some more features are supported
Visual Studio 2012
Not supported yet
Visual Studio 2010
Automatic Concurrency Variadic
variables, library templates
decltype Memory Custom
Rvalue model literals
references Delegating
Lambda constructors
functions
• Comparison chart between many other compilers:
http://s.sashag.net/rpST0u
5. Implicit variable declaration: The compiler knows what
you mean
(Almost) necessary for anonymous types
Very convenient for complex templates
Easily abused by lazy programmers!
std::map<...> M;
auto iter = M.begin(); //what’s the type of iter?
auto pair = std::make_pair(iter, M.key_range(...));
auto lambda = []() { ... }; //lambdas have an anonymous type
auto ptr = condition ? new class1 : new class2; //ERROR
auto x = 15; auto s = (string)"Hello"; //try to avoid...
6. Automatic iterator over arrays and STL collections
Your collection will work – provide begin(), end(), and an
input iterator over the elements
Up to VC11 Beta: for each … in, a non-standard
Microsoft extension
int numbers[] = ...;
for (int n : numbers) std::cout << n;
std::map<std::string,std::list<int>> M;
for (const auto& pair : M)
for (auto n : pair.second)
std::cout << pair.first << ' ' << pair.second;
7. Use a compile-time expression instead of a type name
Can take the type of any expression
Very useful for templates, forwarding etc.
float arr[15];
decltype(arr[0]) flt_ref = arr[0];
decltype(arr[1]+7) flt;
decltype(rand()) n = rand();
decltype(i+j) sum = i+j;
8. Your function can return a decltype
Requires special syntax in these examples because the return
type depends on parameter types
template <typename T1, typename T2>
auto multiply(const T1& t1, const T2& t2) -> decltype(t1+t2) {
return t1 * t2;
}
template <typename InputIterator>
auto nth_element(InputIterator iter, int n) -> decltype(*iter) {
while (--n > 0) ++iter;
return *iter;
}
9. Initialize arrays, lists, vectors, other containers—and
your own containers—with a natural syntax
Not yet supported by Visual Studio 2012
vector<int> v { 1, 2, 3, 4 };
list<string> l = { “Tel-Aviv”, “Jerusalem” };
my_cont c { 42, 43, 44 };
class my_cont {
public: my_cont(std::initializer_list<int> list) {
for (auto it = list.begin(); it != list.end(); ++it) . . .
}
};
10. int main() {
[](){}();
[]{}();
} //this is legal C++,
//although not useful
11. The current state of function objects and operations on
them leaves much to be desired
Must use arcane binding functions, placeholders, and
rules to construct composite functors
class employee {
public: void bonus(float commission, int vacation);
};
vector<int> employees;
std::for_each(employees.begin(), employees.end(),
std::bind(std::mem_fn(&employee::bonus), _1, 0.25f, 3));
12. TR1 makes it somewhat easier to manipulate functors
(functions and classes with operator())
Doesn’t make it easier to create functors
std::function<bool(int,int)> g = greater<int>();
std::function<int(int,char**)> m = main;
std::function<bool(int)> greater_than17 = std::bind(g, _1, 17);
std::function<void(X*)> f = &X::foo; //foo is a member function
13. Inline methods in other methods (closures)
Compile to an anonymous class that serves as a function object
Rich capture semantics by value and by reference
auto print_num = [](int n) { std::cout << n; };
std::list<int> ns = ...;
std::for_each(ns.begin(), ns.end(), print_num);
int even = std::count_if(ns.begin(), ns.end(), [](int n) { return n&1==0;
});
int x = 5;
[&x]() { ++x; }(); //capture by reference
[ x]() { ++x; }(); //capture by value. doesn’t compile!!
14. Default capture (use at your own risk)
Mutable lambdas
Explicit return value
int fib1 = 1, fib2 = 1;
auto next_step = [&]() { //default capture by reference
int temp = fib2; fib2 = fib2 + fib1; fib1 = temp;
};
for (int i = 0; i < 20; ++i) next_step();
int n = 10;
auto say_yes_n_times = [=]() mutable ->bool { //default capture by value,
return (--n > 0); //mutable and returns bool
};
15. std::function<...> to the rescue
Freely manipulate lambdas as objects
auto identity = [](int x) {
return [x]() { return x; };
};
auto next = [](const std::function<int(void)>& lambda) {
return [&lambda]() { return lambda() + 1; };
};
auto _1 = identity(1);
auto _2 = next(_1);
auto _3 = next(_2);
std::cout << _1() << _2() << _3();
16. Recall our contrived bind(mem_fn(…)) example
Use a lambda instead of composite functors
Design your APIs with lambdas in mind
std::for_each(employees.begin(), employees.end(),
std::bind(memfn(&employee::bonus), _1, 0.25f, 3));
std::for_each(employees.begin(), employees.end(),
[](const employee& e) { e.bonus(0.25f, 3); });
template <typename Callback>
void enum_windows(const string& title, Callback callback) {
. . . callback(current_window);
}
//or, use const std::function<void(const window&)>& as parameter
17. Lvalues are values that have a name
Can appear on the left-hand-side of an assignment
Rvalues are the rest
int x;
x = 42; //OK, x has a name, it’s an lvalue
42 = x; //Obviously wrong, 42 does not have a name, it’s an rvalue
x + 2 = 42; //Also wrong, x + 2 returns a temporary, it’s an rvalue
x++ = 42; //Also wrong, x++ returns a temporary, it’s an rvalue
int& foo();
int* goo();
--foo(); //OK, foo() returns an lvalue
++(*goo()); //OK, a dereferenced pointer is an lvalue
18. Turns out, this “standard” approach to references limits
the performance of the language
In this example, the contents of the vectors are COPIED
void init_vector(vector<int>& v);
vector<int> v, w;
init_vector(v); //no copy, we were careful to pass a reference
init_vector(w); //no copy, we were careful to pass a reference
swap(v, w);
//internally, swap will copy v to temp, w to v, temp to w, for a total
//of THREE MEMORY ALLOCATIONS AND DEALLOCATIONS!
//but how can we tell swap (and vector) to MOVE the contents around?
19. Rvalue references are references to rvalues!
Standard references are to lvalues, const references may refer to
temporary rvalues
Enable move construction and assignment
my_array(const my_array& other) { //copy ctor
dataptr_ = new T[size_ = other.size_];
memcpy_s(dataptr_, size_*sizeof(T), other.dataptr_, size_*sizeof(T));
}
my_array& operator=(const my_array& other) { /*same deal*/ }
my_array& operator=(my_array&& other) { //move assignment
dataptr_ = other.dataptr_; size_ = other.size_;
other.dataptr_ = nullptr; other.size_ = 0;
}
my_array(my_array&& other) { //move ctor
*this = std::move(other); //NOTE: && is lvalue in the method body
}
20. • Much fewer copies of temporary objects float around
– E.g. consider std::vector<T> with reallocation
– Huge performance boost when your types are used in STL
– Huge performance boost when using strings and other types
with inner state that is expensive to copy
21. • Use auto, for each, initializer lists ubiquitously
• Don’t be afraid of returning objects by value
– RVO, NRVO, and move constructors will minimize copies
• OK to design algorithms that require predicates,
projections, and other functors
– They will be easy to use—with lambda functions
• Use STL algorithms more widely with lambdas
22. Four standard unordered containers which use hash
tables as their implementation
unordered_map, unordered_set,
unordered_multimap, unordered_multiset
set<string> names = { “Mike”, “Adam” };
assert(*names.begin() == “Adam”);
unordered_set<string> names = { “John”, “Abe” };
for (auto name : names)
cout << name; //alphabetic order is NOT guaranteed
23. PERL-style regular expression facility offered by
std::regex class and associated functions
regex version("(d+).(d+).(d+)");
string text = "2.0.50727";
cmatch captures;
if (regex_search(text.c_str(), captures, version)) {
cout << "Major: " << captures[0] << endl;
cout << "Build: " << captures[2] << endl;
}
//there’s also regex_replace for obvious purposes
24. • The standard library now has three types of smart
pointers, eliminating the need to ever use delete
• If you are the sole owner of the object, use
unique_ptr to make sure it’s deleted when the
pointer dies (RAII)
• If you want to share the object with others, use
shared_ptr—it will perform smart reference
counting
• If you got yourself a cycle, use weak_ptr to break it!
25. Sole owner of an object
Supports move semantics, but not copy semantics
Replaces auto_ptr (which can’t move!)
unique_ptr<expensive_thing> create() {
unique_ptr<expensive_thing> p(new expensive_thing);
//...do some initialization, exceptions are covered by RAII
return p;
}
unique_ptr<expensive_thing> p = create(); //move constructor used!
//another example is storing pointers in containers:
vector<unique_ptr<string>> v = { new string(“A”), new string(“B”) };
26. Thread-safe reference-counted pointer to an object
with shared ownership
When the last pointer dies, the object is deleted
struct file_handle {
HANDLE handle;
file_handle(const string& filename) ...
~file_handle() ... //closes the handle
};
class file {
shared_ptr<file_handle> _handle;
public:
file(const string& filename) : _handle(new file_handle(filename)) {}
file(shared_ptr<file_handle> fh) : _handle(fh) {}
}; //can have multiple file objects over the same file_handle
27. Points to a shared object but does not keep it alive
(does not affect reference count)
The object may be destroyed “under our nose” at any time
Breaks cycles between shared_ptrs
class employee {
weak_ptr<employee> _manager;
vector<shared_ptr<employee>> _direct_reports;
public:
void beg_for_vacation(int days) {
if (auto mgr = _manager.lock()) { mgr->beg(days); } //mgr is shared_ptr
else { /* your manager has been eliminated :-) */ }
}
};
28. • Use smart pointers—no reason to have a delete
statement in your code
– If you’re the only owner, use unique_ptr
– If you’re sharing the object, use shared_ptr
– Create shared_ptrs with make_shared()
– To prevent cycles, use weak_ptr
• Use the non-member begin() and end() functions
– They work on arrays, and can be overloaded for types you
don’t control
31. • Bjarne Stroustrup’s FAQ: http://s.sashag.net/vWT1eI
• C++11 Wikipedia article: http://s.sashag.net/vdSCW3
• What’s New in VC++ 10: http://s.sashag.net/tb1fnr
• What’s New in VC++ 11: http://s.sashag.net/sXy26y
• More on rvalue references: http://s.sashag.net/uVLJ23
• STL11 preliminary docs: http://s.sashag.net/vWR7sW
• C++ memory model: http://s.sashag.net/rqsoDW
• Modern C++ style: http://s.sashag.net/rP5DFl
Editor's Notes
The standardsyntax also allows for (auto& n : numbers) { ++n; }, i.e. going over the elements with a mutable iterator.The Microsoft syntax allows this as well, with for each (auto& n in numbers) { ++n; }.
VC11 does not support initializer lists yet.More examples for uniform initialization:struct X { X(inti, int j); };void f(X);f({1,2});std::complex<double> c {1.0,1.0};
std::bind and std::mem_fn are really state-of-the-art (from TR1) considering the state of affairs using vanilla C++98.Namely, we had pointer_to_unary_function, bind1st, bind2nd, and similar stuff.
Mention that stateless lambdas (beginning with [], such that they don’t capture any local variables) are implicitly convertible to function pointers. (But only in VS11 :-))
There is a slightly complicated point in the move constructor here. If the move constructor were to use the assignment directly, e.g. *this = other, then the standard operator= would be called. The reason is that rvalue references are treated as lvalues as long as they have a name. What std::move does is pass its parameter through, and by doing that it removes its name so the caller treats it as an unnamed object, and hence an rvalue. (The reason for this quirk, in turn, is to prevent accidental moves that will destroy the object. E.g. you could move from other, and then attempt to use other later in your method.)After we have a container that works like this, we can also have an std::swap that works appropriately—it will simply use std::move instead of just the assignment operator to move the swapped data around (through a temporary variable), i.e.: temp = move(a); a = move(b); b = move(temp); — and no copies of the contents are required.
Note that Microsoft had stdext::hash_map previously, and nearly everyone else did, too. Unclear how this will merge in.There is another new kind of collection—std::array<T,N>—which is a compile-time sized array with begin() and end() member functions for use with STL collections requiring an iterator in a natural fashion.