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.
[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
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)
talk at Virginia Bioinformatics Institute, December 5, 2013ericupnorth
Extensible domain-specific programming for the sciences
The notion of scientists as programmers begs the question of what sort of programming language would be a good fit. The common answer seems to be both none of them and all of them. Many scientific applications are a combination of general-purpose and domain-specific languages: R for statistical elements, MATLAB for matrix-based computations, Perl-based regular expressions for string matching, C or FORTRAN for high performance parallel computations, and scripting languages such as Python to glue them all together. This clumsy situation demonstrates the need for different domain-specific language features.
Our hypothesis is that programming could be made easier, less error-prone and result in higher-quality code if languages could be easily extended, by the programmer, with the domain-specific features that a programmer or scientists needs for their particular task at hand. This talk demonstrates the meta-language processing tools that support this composition of programmer-selected language features, with several extensions chosen from the previously mentioned list of features.
[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
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)
talk at Virginia Bioinformatics Institute, December 5, 2013ericupnorth
Extensible domain-specific programming for the sciences
The notion of scientists as programmers begs the question of what sort of programming language would be a good fit. The common answer seems to be both none of them and all of them. Many scientific applications are a combination of general-purpose and domain-specific languages: R for statistical elements, MATLAB for matrix-based computations, Perl-based regular expressions for string matching, C or FORTRAN for high performance parallel computations, and scripting languages such as Python to glue them all together. This clumsy situation demonstrates the need for different domain-specific language features.
Our hypothesis is that programming could be made easier, less error-prone and result in higher-quality code if languages could be easily extended, by the programmer, with the domain-specific features that a programmer or scientists needs for their particular task at hand. This talk demonstrates the meta-language processing tools that support this composition of programmer-selected language features, with several extensions chosen from the previously mentioned list of features.
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.
This presentation was held at the Stockholm Rust Meetup in September 2019.
This is a brief introduction to Rust and highlights some of the problems with C++ that it attempts to solve. It also contain a brief introduction to the ownership model and the borrow checker that Rust uses.
C++20 comes with some big new language features: modules, coroutines, concepts, spaceship, and many new libraries. But apart from all those, C++20 also offers many small language improvements, making C++ more powerful and expressive, but also safer and more consistent. This talk is an overview over all those smaller additions to the core language that will make your life easier. We will discuss much-needed improvements to existing facilities such as lambdas, CTAD, structured bindings, and initialisation, as well as brand-new language utilities that you may not yet have heard about!
A presentation given at the Programming Languages Meetup in San Francisco (Jun 10, 2014). Computation is about communicating state machines, but the message is lost in the endless debates on threads vs. events, iterators vs.. reactive approaches. There are lightweight coroutine and thread options available in all major mainstream languages, which help combine the easy sequential thread programming, with performance of event-oriented code. You can have it all.
Workshop about TensorFlow usage for AI Ukraine 2016. Brief tutorial with source code example. Described TensorFlow main ideas, terms, parameters. Example related with linear neuron model and learning using Adam optimization algorithm.
Intro to Python for High School Students.
Unit #2: classes, as well as docstrings, lambda, map, filter, logging, testing, debugging
Does not include GUI content
Brief overview of the Rust system programming language. Provides a concise introduction of its basic features, with an emphasis on its memory safety features (ownership, moves, borrowing) and programming style with generic functions, structures, and traits.
This was a presentation that TK Kuegler conducted at Phoenix Startup Week.
The first topic that any new entrepreneurial effort has to tackle is the idea generation. In a nutshell: What problem will my company solve? This class will cover brainstorming concepts, idea selection, and early problem solving formulation. The goal at the end of the class is that a participant will be able to identify 1 to 3 ideas that have a reasonable chance to turn into a company.
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.
This presentation was held at the Stockholm Rust Meetup in September 2019.
This is a brief introduction to Rust and highlights some of the problems with C++ that it attempts to solve. It also contain a brief introduction to the ownership model and the borrow checker that Rust uses.
C++20 comes with some big new language features: modules, coroutines, concepts, spaceship, and many new libraries. But apart from all those, C++20 also offers many small language improvements, making C++ more powerful and expressive, but also safer and more consistent. This talk is an overview over all those smaller additions to the core language that will make your life easier. We will discuss much-needed improvements to existing facilities such as lambdas, CTAD, structured bindings, and initialisation, as well as brand-new language utilities that you may not yet have heard about!
A presentation given at the Programming Languages Meetup in San Francisco (Jun 10, 2014). Computation is about communicating state machines, but the message is lost in the endless debates on threads vs. events, iterators vs.. reactive approaches. There are lightweight coroutine and thread options available in all major mainstream languages, which help combine the easy sequential thread programming, with performance of event-oriented code. You can have it all.
Workshop about TensorFlow usage for AI Ukraine 2016. Brief tutorial with source code example. Described TensorFlow main ideas, terms, parameters. Example related with linear neuron model and learning using Adam optimization algorithm.
Intro to Python for High School Students.
Unit #2: classes, as well as docstrings, lambda, map, filter, logging, testing, debugging
Does not include GUI content
Brief overview of the Rust system programming language. Provides a concise introduction of its basic features, with an emphasis on its memory safety features (ownership, moves, borrowing) and programming style with generic functions, structures, and traits.
This was a presentation that TK Kuegler conducted at Phoenix Startup Week.
The first topic that any new entrepreneurial effort has to tackle is the idea generation. In a nutshell: What problem will my company solve? This class will cover brainstorming concepts, idea selection, and early problem solving formulation. The goal at the end of the class is that a participant will be able to identify 1 to 3 ideas that have a reasonable chance to turn into a company.
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
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.
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.
Thrift vs Protocol Buffers vs Avro - Biased ComparisonIgor Anishchenko
Igor Anishchenko
Odessa Java TechTalks
Lohika - May, 2012
Let's take a step back and compare data serialization formats, of which there are plenty. What are the key differences between Apache Thrift, Google Protocol Buffers and Apache Avro. Which is "The Best"? Truth of the matter is, they are all very good and each has its own strong points. Hence, the answer is as much of a personal choice, as well as understanding of the historical context for each, and correctly identifying your own, individual requirements.
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++
Trends and future of C++: Evolving a systems language for performance - by Bj...devstonez
Bjarne Stroustrup presentation at Universidad Carlos III de Madrid, march 18 2011 on :
- The design of C++0x
- C++: Machine model and resource management
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
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
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.
PHP Frameworks: I want to break free (IPC Berlin 2024)Ralf Eggert
In this presentation, we examine the challenges and limitations of relying too heavily on PHP frameworks in web development. We discuss the history of PHP and its frameworks to understand how this dependence has evolved. The focus will be on providing concrete tips and strategies to reduce reliance on these frameworks, based on real-world examples and practical considerations. The goal is to equip developers with the skills and knowledge to create more flexible and future-proof web applications. We'll explore the importance of maintaining autonomy in a rapidly changing tech landscape and how to make informed decisions in PHP development.
This talk is aimed at encouraging a more independent approach to using PHP frameworks, moving towards a more flexible and future-proof approach to PHP development.
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.
SAP Sapphire 2024 - ASUG301 building better apps with SAP Fiori.pdfPeter Spielvogel
Building better applications for business users with SAP Fiori.
• What is SAP Fiori and why it matters to you
• How a better user experience drives measurable business benefits
• How to get started with SAP Fiori today
• How SAP Fiori elements accelerates application development
• How SAP Build Code includes SAP Fiori tools and other generative artificial intelligence capabilities
• How SAP Fiori paves the way for using AI in SAP apps
Bjarne Stroustrup - The Essence of C++: With Examples in C++84, C++98, C++11, and C++14
1. The Essence of C++
with examples in C++84, C++98, C++11, and C++14
Bjarne Stroustrup
Texas A&M University
www.stroustrup.com
2. Overview
•
•
•
•
Aims and constraints
C++ in four slides
Resource management
OOP: Classes and Hierarchies
– (very briefly)
• GP: Templates
– Requirements checking
• Challenges
Stroustrup - Essence - Going Native'13
3
3. What did/do I want?
• Type safety
– Encapsulate necessary unsafe operations
• Resource safety
– It’s not all memory
• Performance
– For some parts of almost all systems, it’s important
• Predictability
– For hard and soft real time
• Teachability
– Complexity of code should be proportional to the complexity of the task
• Readability
– People and machines (“analyzability”)
Stroustrup - Essence - Going Native'13
4
4. Who did/do I want it for?
• Primary concerns
–
–
–
–
Systems programming
Embedded systems
Resource constrained systems
Large systems
• Experts
– “C++ is expert friendly”
• Novices
– C++ Is not just expert friendly
Stroustrup - Essence - Going Native'13
5
5. Template
meta-programming!
What is C++?
Class hierarchies
A hybrid language
A multi-paradigm
programming language
Buffer
overflows
It’s C!
Classes
Embedded systems
programming language
Too big!
An object-oriented
programming language
Generic programming
Stroustrup - Essence - Going Native'13
Low level!
A random collection
of features
6
6. C++
A light-weight abstraction
programming language
Key strengths:
• software infrastructure
• resource-constrained applications
Stroustrup - Essence - Going Native'13
7
8. What does C++ offer?
• Not perfection
– Of course
• Not everything for everybody
– Of course
• A solid fundamental model
– Yes, really
• 30+ years of real-world “refinement”
– It works
• Performance
– A match for anything
• The best is buried in “compatibility stuff’’
– long-term stability is a feature
Stroustrup - Essence - Going Native'13
9
9. What does C++ offer?
• C++ in Four slides
–
–
–
–
Map to hardware
Classes
Inheritance
Parameterized types
• If you understand int and vector, you understand C++
– The rest is “details” (1,300+ pages of details)
Stroustrup - Essence - Going Native'13
10
10. Map to Hardware
• Primitive operations => instructions
– +, %, ->, [], (), …
value
• int, double, complex<double>, Date, …
handle
• vector, string, thread, Matrix, …
value
• Objects can be composed by simple concatenation:
– Arrays
– Classes/structs
value
handle
value
handle
value
value
Stroustrup - Essence - Going Native'13
11
11. Classes: Construction/Destruction
• From the first week of “C with Classes” (1979)
class X {
// user-defined type
public:
// interface
X(Something); // constructor from Something
~X();
// destructor
// …
private:
// implementation
// …
};
“A constructor establishes the environment for the members to
run in; the destructor reverses its actions.”
Stroustrup - Essence - Going Native'13
12
12. Abstract Classes and Inheritance
• Insulate the user from the implementation
struct Device {
virtual int put(const char*) = 0;
virtual int get(const char*) = 0;
};
// abstract class
// pure virtual function
• No data members, all data in derived classes
– “not brittle”
• Manipulate through pointer or reference
– Typically allocated on the free store (“dynamic memory”)
– Typically requires some form of lifetime management (use resource
handles)
• Is the root of a hierarchy of derived classes
Stroustrup - Essence - Going Native'13
13
13. Parameterized Types and Classes
• Templates
– Essential: Support for generic programming
– Secondary: Support for compile-time computation
template<typename T>
class vector { /* … */ };
// a generic type
vector<double> constants = {3.14159265359, 2.54, 1, 6.62606957E-34, }; // a use
template<typename C>
void sort (Cont& c) { /* … */ }
// a generic function
sort(constants);
// a use
Stroustrup - Essence - Going Native'13
14
14. Not C++ (fundamental)
• No crucial dependence on a garbage collector
– GC is a last and imperfect resort
• No guaranteed type safety
– Not for all constructs
– C compatibility, history, pointers/arrays, unions, casts, …
• No virtual machine
– For many reasons, we often want to run on the real machine
– You can run on a virtual machine (or in a sandbox) if you want to
Stroustrup - Essence - Going Native'13
15
15. Not C++ (market realities)
• No huge “standard” library
– No owner
• To produce “free” libraries to ensure market share
– No central authority
• To approve, reject, and help integration of libraries
• No standard
– Graphics/GUI
• Competing frameworks
– XML support
– Web support
– …
Stroustrup - Essence - Going Native'13
16
17. Resource management
• A resource should be owned by a “handle”
– A “handle” should present a well-defined and useful abstraction
• E.g. a vector, string, file, thread
• Use constructors and a destructor
class Vector {
// vector of doubles
Vector(initializer_list<double>); // acquire memory; initialize elements
~Vector();
// destroy elements; release memory
// …
private:
double* elem;
// pointer to elements
int sz;
// number of elements
handle
};
void fct()
{
Vector v {1, 1.618, 3.14, 2.99e8};
// …
}
Value
// vector of doubles
Stroustrup - Essence - Going Native'13
18
18. Resource management
• A handle usually is scoped
– Handles lifetime (initialization, cleanup), and more
Vector::Vector(initializer_list<double> lst)
:elem {new double[lst.size()]}, sz{lst.size()};
{
uninitialized_copy(lst.begin(),lst.end(),elem);
}
Vector::~Vector()
{
delete[] elem;
};
// acquire memory
// initialize elements
// destroy elements; release memory
Stroustrup - Essence - Going Native'13
19
19. Resource management
• What about errors?
–
–
–
–
A resource is something you acquire and release
A resource should have an owner
Ultimately “root” a resource in a (scoped) handle
“Resource Acquisition Is Initialization” (RAII)
• Acquire during construction
• Release in destructor
– Throw exception in case of failure
• Can be simulated, but not conveniently
– Never throw while holding a resource not owned by a handle
• In general
– Leave established invariants intact when leaving a scope
Stroustrup - Essence - Going Native'13
20
20. “Resource Acquisition is Initialization” (RAII)
• For all resources
– Memory (done by std::string, std::vector, std::map, …)
– Locks (e.g. std::unique_lock), files (e.g. std::fstream), sockets, threads
(e.g. std::thread), …
std::mutex mtx;
int sh;
// a resource
// shared data
void f()
{
std::lock_guard lck {mtx}; // grab (acquire) the mutex
sh+=1;
// manipulate shared data
}
// implicitly release the mutex
Stroustrup - Essence - Going Native'13
21
21. Pointer Misuse
• Many (most?) uses of pointers in local scope are not exception safe
void f(int n, int x)
{
Gadget* p = new Gadget{n};
// look I’m a java programmer!
// …
if (x<100) throw std::runtime_error{“Weird!”};
// leak
if (x<200) return;
// leak
// …
delete p;
// and I want my garbage collector!
}
– But, garbage collection would not release non-memory resources anyway
– But, why use a “naked” pointer?
Stroustrup - Essence - Going Native'13
22
22. Resource Handles and Pointers
• A std::shared_ptr releases its object at when the last shared_ptr to
it is destroyed
void f(int n, int x)
{
shared_ptr<Gadget> p {new Gadget{n}}; // manage that pointer!
// …
if (x<100) throw std::runtime_error{“Weird!”};
// no leak
if (x<200) return;
// no leak
// …
}
– shared_ptr provides a form of garbage collection
– But I’m not sharing anything
•
use a unique_ptr
Stroustrup - Essence - Going Native'13
23
23. Resource Handles and Pointers
• But why use a pointer at all?
• If you can, just use a scoped variable
void f(int n, int x)
{
Gadget g {n};
// …
if (x<100) throw std::runtime_error{“Weird!”};
if (x<200) return;
// …
}
Stroustrup - Essence - Going Native'13
// no leak
// no leak
24
24. Why do we use pointers?
• And references, iterators, etc.
• To represent ownership
– Don’t! Instead, use handles
• To reference resources
– from within a handle
• To represent positions
– Be careful
• To pass large amounts of data (into a function)
– E.g. pass by const reference
• To return large amount of data (out of a function)
– Don’t! Instead use move operations
Stroustrup - Essence - Going Native'13
25
25. How to get a lot of data cheaply out of a function?
• Ideas
– Return a pointer to a new’d object
• Who does the delete?
- Return a reference to a new’d object
- Who does the delete?
- Delete what?
- Pass a target object
- We are regressing towards assembly code
- Return an object
- Copies are expensive
- Tricks to avoid copying are brittle
- Tricks to avoid copying are not general
- Return a handle
- Simple and cheap
Stroustrup - Essence - Going Native'13
26
26. Move semantics
• Return a Matrix
Matrix operator+(const Matrix& a, const Matrix& b)
{
Matrix r;
// copy a[i]+b[i] into r[i] for each i
return r;
}
Matrix res = a+b;
• Define move a constructor for Matrix
– don’t copy; “steal the representation”
r:
res:
……..
Stroustrup - Essence - Going Native'13
27
27. Move semantics
• Direct support in C++11: Move constructor
class Matrix {
Representation rep;
// …
Matrix(Matrix&& a)
{
rep = a.rep;
a.rep = {};
}
};
// move constructor
// *this gets a’s elements
// a becomes the empty Matrix
Matrix res = a+b;
r:
res:
……..
Stroustrup - Essence - Going Native'13
28
28. No garbage collection needed
• For general, simple, implicit, and efficient resource management
• Apply these techniques in order:
1.
Store data in containers
•
•
2.
Manage all resources with resource handles
•
•
3.
RAII
Not just memory: all resources
Use “smart pointers”
•
4.
The semantics of the fundamental abstraction is reflected in the interface
Including lifetime
They are still pointers
Plug in a garbage collector
• For “litter collection”
• C++11 specifies an interface
• Can still leak non-memory- Essence - Going Native'13
resources
Stroustrup
29
29. Range-for, auto, and move
• As ever, what matters is how features work in combination
template<typename C, typename V>
vector<Value_type<C>*> find_all(C& c, V v) // find all occurrences of v in c
{
vector<Value_type<C>*> res;
for (auto& x : c)
if (x==v)
res.push_back(&x);
return res;
}
string m {"Mary had a little lamb"};
for (const auto p : find_all(m,'a')) // p is a char*
if (*p!='a')
cerr << "string bug!n";
Stroustrup - Essence - Going Native'13
30
30. RAII and Move Semantics
• All the standard-library containers provide it
•
•
•
•
•
•
vector
list, forward_list (singly-linked list), …
map, unordered_map (hash table),…
set, multi_set, …
…
string
• So do other standard resources
•
•
•
•
thread, lock_guard, …
istream, fstream, …
unique_ptr, shared_ptr
…
Stroustrup - Essence - Going Native'13
31
32. Class hierarchies
Class’ own members
Derived classes
All users
• Protection model
public
protected
• No universal base class
private
– an unnecessary implementation-oriented artifact
– imposes avoidable space and time overheads.
– encourages underspecified (overly general) interfaces
• Multiple inheritance
– Separately consider interface and implementation
– Abstract classes provide the most stable interfaces
• Minimal run-time type identification
– dynamic_cast<D*>(pb)
Stroustrup - Essence - Going Native'13
– typeid(p)
33
33. Inheritance
• Use it
– When the domain concepts are hierarchical
– When there is a need for run-time selection among hierarchically ordered
alternatives
• Warning:
– Inheritance has been seriously and systematically overused and misused
• “When your only tool is a hammer everything looks like a nail”
Stroustrup - Essence - Going Native'13
34
35. Generic Programming: Templates
• 1980: Use macros to express generic types and functions
• 1987 (and current) aims:
– Extremely general/flexible
• “must be able to do much more than I can imagine”
– Zero-overhead
• vector/Matrix/… to compete with C arrays
– Well-specified interfaces
• Implying overloading, good error messages, and maybe separate
compilation
• “two out of three ain’t bad”
– But it isn’t really good either
– it has kept me concerned/working for 20+ years
Stroustrup - Essence - Going Native'13
36
36. Templates
• Compile-time duck typing
– Leading to template metaprogramming
• A massive success in C++98, better in C++11, better still in C++14
– STL containers
• template<typename T> class vector { /* … */ };
– STL algorithms
• sort(v.begin(),v.end());
– And much more
• Better support for compile-time programming
– C++11: constexpr (improved in C++14)
Stroustrup - Essence - Going Native'13
37
37. Algorithms
• Messy code is a major source of errors and inefficiencies
• We must use more explicit, well-designed, and tested algorithms
• The C++ standard-library algorithms are expressed in terms of
half-open sequences [first:last)
– For generality and efficiency
void f(vector<int>& v, list<string>& lst)
{
sort(v.begin(),v.end());
// sort the vector using <
auto p = find(lst.begin(),lst.end(),"Aarhus"); // find “Aarhus” in the list
// …
}
• We parameterize over element type and container type
Stroustrup - Essence - Going Native'13
38
38. Algorithms
• Simple, efficient, and general implementation
– For any forward iterator
– For any (matching) value type
template<typename Iter, typename Value>
Iter find(Iter first, Iter last, Value val) // find first p in [first:last) so that *p==val
{
while (first!=last && *first!=val)
++first;
return first;
}
Stroustrup - Essence - Going Native'13
39
39. Algorithms and Function Objects
• Parameterization with criteria, actions, and algorithms
– Essential for flexibility and performance
void g(vector< string>& vs)
{
auto p = find_if(vs.begin(), vs.end(), Less_than{"Griffin"});
// …
}
Stroustrup - Essence - Going Native'13
40
40. Algorithms and Function Objects
• The implementation is still trivial
template<typename Iter, typename Predicate>
Iter find_if(Iter first, Iter last, Predicate pred) // find first p in [first:last) so that pred(*p)
{
while (first!=last && !pred(*first))
++first;
return first;
}
Stroustrup - Essence - Going Native'13
41
41. Function Objects and Lambdas
• General function object
– Can carry state
– Easily inlined (i.e., close to optimally efficient)
struct Less_than {
String s;
Less_than(const string& ss) :s{ss} {} // store the value to compare against
bool operator()(const string& v) const { return v<s; } // the comparison
};
Lambda notation
– We can let the compiler write the function object for us
auto p = std::find_if(vs.begin(),vs.end(),
[](const string& v) { return v<"Griffin"; } );
Stroustrup - Essence - Going Native'13
42
42. Container algorithms
• The C++ standard-library algorithms are expressed in terms of halfopen sequences [first:last)
– For generality and efficiency
– If you find that verbose, define container algorithms
namespace Extended_STL {
// …
template<typename C, typename Predicate>
Iterator<C> find_if(C& c, Predicate pred)
{
return std::find_if(c.begin(),c.end(),pred);
}
// …
}
auto p = find_if(v, [](int x) { return x%2; } );
Stroustrup - Essence - Going Native'13
// assuming v is a vector<int>
43
43. Duck Typing is Insufficient
• There are no proper interfaces
• Leaves error detection far too late
– Compile- and link-time in C++
• Encourages a focus on implementation details
– Entangles users with implementation
• Leads to over-general interfaces and data structures
– As programmers rely on exposed implementation “details”
• Does not integrate well with other parts of the language
– Teaching and maintenance problems
• We must think of generic code in ways similar to other code
– Relying on well-specified interfaces (like OO, etc.)
Stroustrup - Essence - Going Native'13
44
44. Generic Programming is just Programming
• Traditional code
double sqrt(double d);
double d = 7;
double d2 = sqrt(d);
double d3 = sqrt(&d);
// C++84: accept any d that is a double
// fine: d is a double
// error: &d is not a double
• Generic code
void sort(Container& c); // C++14: accept any c that is a Container
vector<string> vs { "Hello", "new", "World" };
sort(vs);
// fine: vs is a Container
sort(&vs);
// error: &vs is not a Container
Stroustrup - Essence - Going Native'13
45
45. C++14: Constraints aka “Concepts lite”
• How do we specify requirements on template arguments?
– state intent
• Explicitly states requirements on argument types
– provide point-of-use checking
• No checking of template definitions
– use constexpr functions
•
•
•
•
Voted as C++14 Technical Report
Design by B. Stroustrup, G. Dos Reis, and A. Sutton
Implemented by Andrew Sutton in GCC
There are no C++0x concept complexities
– No concept maps
– No new syntax for defining concepts
– No new scope and lookup issues - Going Native'13
Stroustrup - Essence
46
46. What is a Concept?
• Concepts are fundamental
– They represent fundamental concepts of an application area
– Concepts are come in “clusters” describing an application area
• A concept has semantics (meaning)
– Not just syntax
– “Subtractable” is not a concept
• We have always had concepts
–
–
–
–
C++: Integral, arithmetic
STL: forward iterator, predicate
Informally: Container, Sequence
Algebra: Group, Ring, …
Stroustrup - Essence - Going Native'13
47
47. What is a Concept?
• Don’t expect to find a new fundamental concept every year
• A concept is not the minimal requirements for an implementation
– An implementation does not define the requirements
– Requirements should be stable
• Concepts support interoperability
– There are relatively few concepts
– We can remember a concept
Stroustrup - Essence - Going Native'13
48
48. C++14 Concepts (Constraints)
• A concept is a predicate on one or more arguments
– E.g. Sequence<T>()
// is T a Sequence?
• Template declaration
template <typename S, typename T>
requires Sequence<S>()
&& Equality_comparable<Value_type<S>, T>()
Iterator_of<S> find(S& seq, const T& value);
• Template use
void use(vector<string>& vs)
{
auto p = find(vs,"Jabberwocky");
// …
Stroustrup - Essence - Going Native'13
}
49
49. C++14 Concepts: Error handling
• Error handling is simple (and fast)
template<Sortable Cont>
void sort(Cont& container);
vector<double> vec {1.2, 4.5, 0.5, -1.2};
list<int> lst {1, 3, 5, 4, 6, 8,2};
sort(vec);
sort(lst);
// OK: a vector is Sortable
// Error at (this) point of use: Sortable requires random access
• Actual error message
error: ‘list<int>’ does not satisfy the constraint ‘Sortable’
Stroustrup - Essence - Going Native'13
50
50. C++14 Concepts: “Shorthand Notation”
• Shorthand notation
template <Sequence S, Equality_comparable<Value_type<S>> T>
Iterator_of<C> find(S& seq, const T& value);
• We can handle essentially all of the Palo Alto TR
– (STL algorithms) and more
• Except for the axiom parts
– We see no problems checking template definitions in isolation
• But proposing that would be premature (needs work, experience)
– We don’t need explicit requires much (the shorthand is usually fine)
Stroustrup - Essence - Going Native'13
51
51. C++14 Concepts: Overloading
• Overloading is easy
template <Sequence S, Equality_comparable<Value_type<S>> T>
Iterator_of<S> find(S& seq, const T& value);
template<Associative_container C>
Iterator_type<C> find(C& assoc, const Key_type<C>& key);
vector<int> v { /* ... */ };
multiset<int> s { /* … */ };
auto vi = find(v, 42);
auto si = find(s, 12-12-12);
// calls 1st overload:
// a vector is a Sequence
// calls 2nd overload:
// a multiset is an Associative_container
Stroustrup - Essence - Going Native'13
52
52. C++14 Concepts: Overloading
• Overloading based on predicates
– specialization based on subset
– Far easier than writing lots of tests
template<Input_iterator Iter>
void advance(Iter& p, Difference_type<Iter> n) { while (n--) ++p; }
template<Bidirectional_iterator Iter>
void advance(Iter& i, Difference_type<Iter> n)
{ if (n > 0) while (n--) ++p; if (n < 0) while (n++) --ip}
template<Random_access_iterator Iter>
void advance(Iter& p, Difference_type<Iter> n) { p += n; }
• We don’t say
Input_iterator < Bidirectional_iterator < Random_access_iterator
we compute it
Stroustrup - Essence - Going Native'13
53
53. C++14 Concepts: Definition
• How do you write constraints?
– Any bool expression
• Including type traits and constexpr function
– a requires(expr) expression
• requires() is a compile time intrinsic function
• true if expr is a valid expression
• To recognize a concept syntactically, we can declare it concept
– Rather than just constexpr
Stroustrup - Essence - Going Native'13
54
54. C++14 Concepts: “Terse Notation”
• We can use a concept name as the name of a type than satisfy
the concept
void sort(Container& c);
// terse notation
– means
template<Container __Cont>
void sort(__Cont& c);
// shorthand notation
– means
template<typename __Cont>
// explicit use of predicate
requires Container<__Cont>()
void sort(__Cont)& c;
– Accepts any type that is a Container
vector<string> vs;
sort(vs);
Stroustrup - Essence - Going Native'13
55
55. C++14 Concepts: “Terse Notation”
• We have reached the conventional notation
– with the conventional meaning
• Traditional code
double sqrt(double d);
double d = 7;
double d2 = sqrt(d);
double d3 = sqrt(&d);
// C++84: accept any d that is a double
// fine: d is a double
// error: &d is not a double
• Generic code
void sort(Container& c); // C++14: accept any c that is a Container
vector<string> vs { "Hello", "new", "World" };
sort(vs);
// fine: vs is a Container
sort(&vs);
// error: &vs is not a Container
Stroustrup - Essence - Going Native'13
56
56. C++14 Concepts: “Terse Notation”
• Consider std::merge
• Explicit use of predicates:
template<typename For,
typename For2,
typename Out>
requires Forward_iterator<For>()
&& Forward_iterator<For2>()
&& Output_iterator<Out>()
&& Assignable<Value_type<For>,Value_type<Out>>()
&& Assignable<Value_type<For2,Value_type<Out>>()
&& Comparable<Value_type<For>,Value_type<For2>>()
void merge(For p, For q, For2 p2, For2 q2, Out p);
• Headache inducing, and accumulate() is worse
Stroustrup - Essence - Going Native'13
57
57. C++14 Concepts: “Terse Notation”
• Better, use the shorthand notation
template<Forward_iterator For,
Forward_iterator For2,
Output_iterator Out>
requires Mergeable<For,For2,Out>()
void merge(For p, For q, For2 p2, For2 q2, Out p);
• Quite readable
Stroustrup - Essence - Going Native'13
58
58. C++14 Concepts: “Terse Notation”
• Better still, use the “terse notation”:
Mergeable{For,For2,Out} // Mergeable is a concept requiring three types
void merge(For p, For q, For2 p2, For2 q2, Out p);
• The
concept-name { identifier-list }
notation introduces constrained names
• Make simple things simple!
Stroustrup - Essence - Going Native'13
59
59. C++14 Concepts: “Terse Notation”
• Now we just need to define Mergeable:
template<typename For, typename For2, typename Out>
concept bool Mergeable()
{
return Forward_iterator<For>()
&& Forward_iterator<For2>()
&& Output_iterator<Out>()
&& Assignable<Value_type<For>,Value_type<Out>>()
&& Assignable<Value_type<For2,Value_type<Out>>()
&& Comparable<Value_type<For>,Value_type<For2>>();
}
• It’s just a predicate
Stroustrup - Essence - Going Native'13
60
61. C++ Challenges
• Obviously, C++ is not perfect
– How can we make programmers prefer modern styles over low-level code
• which is far more error-prone and harder to maintain, yet no more efficient?
– How can we make C++ a better language given the Draconian constraints
of C and C++ compatibility?
– How can we improve and complete the techniques and models
(incompletely and imperfectly) embodied in C++?
• Solutions that eliminate major C++ strengths are not acceptable
– Compatibility
• link, source code
– Performance
• uncompromising
– Portability
– Range of application areas
• Preferably increasing the range
Stroustrup - Essence - Going Native'13
62
62. Long-term C++ Challenges
• Close more type loopholes
– in particular, find a way to prevent misuses of delete without spoiling RAII
• Simplify concurrent programming
– in particular, provide some higher-level concurrency models as libraries
• Simplify generic programming
– in particular, introduce simple and effective concepts
• Simplify programming using class hierarchies
– in particular, eliminate use of the visitor pattern
• Better support for combinations of object-oriented and generic programming
• Make exceptions usable for hard-real-time projects
– that will most likely be a tool rather than a language change
• Find a good way of using multiple address spaces
– as needed for distributed computing
– would probably involve defining a more general module mechanism that would
also address dynamic linking, and more.
• Provide many more domain-specific libraries
• Develop a more precise and formal specification of C++
Stroustrup - Essence - Going Native'13
63
63. “Paradigms”
• Much of the distinction between object-oriented
programming, generic programming, and “conventional
programming” is an illusion
– based on a focus on language features
– incomplete support for a synthesis of techniques
– The distinction does harm
• by limiting programmers, forcing workarounds
void draw_all(Container& c) // is this OOP, GP, or conventional?
requires Same_type<Value_type<Container>,Shape*>
{
for_each(c, [](Shape* p) { p->draw(); } );
}
Stroustrup - Essence - Going Native'13
64
64. Questions?
C++: A light-weight abstraction
programming language
Key strengths:
• software infrastructure
• resource-constrained applications
Stroustrup - Essence - Going Native'13
Practice type-rich
programming
65