aductores24

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
There seems to be a widely held belief among programmers today that efficiency no longer matters in most situations because processors are so fast and numerous and memory is so large. But from a user’s perspective computers are often slower today than they were 30 years ago despite the enormous increase in measured performance of the hardware. How can this be? If this is true, what are we doing wrong and what can we do about it? Is efficiency an everyday concern for working programmers, or is it only needed for special cases written by specialists?

In this talk we will explore these questions and consider the proposition that, contrary to popular belief, performance almost always matters and pervasive attention to efficiency is essential to ensure good performance. We will examine the efficiency tools modern C++ has to offer and discuss techniques for writing efficient code in an elegant, expressive and natural way. Topics will include tuning vs. optimizing, value semantics vs. reference semantics, unions and variants, move semantics, forwarding, container choice, in-place construction, and container node handling.
—
Alan Talbot, LTK Engineering Services
Manager - Software Engineering

Alan Talbot started programming in 1972, in BASIC on a DEC PDP-8. He began his professional programming career in 1979 and started using C++ in 1989. For 20 years he was a pioneer in music typography software, then spent 8 years writing digital mapping software, and has spent the last 9 years writing railroad simulation software. He has been a member of the C++ Standards Committee since 2005, and most of his Committee work has focused on improvements in efficiency. His contributions include container emplace, extract and merge of associative container nodes, and the emancipation of unions.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
Everyone has an opinion on what build systems should do but there are surprisingly few who have an understanding of how they do it. In this talk we shall look behind the curtain and examine what does it actually take to create a modern build system and how they go about their business of turning source code into either compiler errors or executables.

On this journey we shall learn about the wonders of supporting 10+ different platforms and toolchains, dependency management, the awesomeness (both ironically and not) of shared libraries, compiler bugs and the interesting requirements on tools used at the lowest layers of a modern operating system. Using the increasingly popular Meson build system we shall examine real world design choices and tradeoffs and how they affect the final end user development experience. Performance optimization is also examined by looking at how you can efficiently scale program compilation both up to a compilation cluster and down to something like a Raspberry Pi.

Armed with all this knowledge we should finally be able to answer the question of why almost all build systems have suffered from poor usability and maybe, just maybe, find a proper solution for the build and dependency problem.
—
Jussi Pakkanen
Consultant

Jussi Pakkanen is the creator and project lead of the Meson build system. He is currently working as a consultant. He has experience in many different fields of computing ranging from slot machines to mail sorting, computer security, Linux desktop development and gaming. His free time has been equally colorful, including things such as comics and illustration, directing movies, music and electronics. When not working on projects he might be found watching bad movies, especially sci-fi and the finest of trash from the 80s.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
Since 2012, Google's C++ Library Team has published an essay/guidance series called the "C++ Tip of the Week." Internally, this is used as a sort of secondary to the C++ Style Guide - while the style guide is roughly treated with the force of law, the TotW series is only "very strong guidance." With the release of Abseil at last year's CppCon, we've begun re-publishing the relevant TotW entries on http://abseil.io/tips/.

We think this can serve a good purpose in the public C++ ecosystem. The Core Guidelines cover basically everything, and do a good job, but are often only a shallow summary of the topic at hand. Any given TotW, on the other hand, covers a relatively narrow topic in greater detail.

This talk will give a general overview of the series: it's major themes and most commonly cited entries. As such, this talk will hit on things like: understanding copy vs. move, how to use `emplace`, enums and producing readable APIs, how to construct a unique_ptr clearly, and how to structure your unittests.
—
Jon Cohen
Software Engineer, Google
Jon Cohen is an engineer at Google, maintaining our core common C++ libraries. He spends most of his days directing Google's robot army to rewrite its own source code to be more readable and efficient, and has so far managed to do so without accidentally creating Skynet.

Matt Kulukundis
Staff Software Engineer, Google
Matt is a senior software engineer on the C++ libraries team at Google. Prior to Google he has worked on compilers, machine learning, and underwater robotics. In his free time, he scuba dives in warm places.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
When you have thousands of C++ services and you've just changed a core library, how do you make sure nothing broke? In 2016 we explored what that looks like from the perspective of the engineer changing the library ( https://youtu.be/_YzUD9FvQlg). Now we're going to look at that same problem from perspective of an engineer working on developer experience, providing that safety, all the while trying to make sure we don't break the bank in machine costs. We'll notice patterns, including how saving machines nearly always means saving developer time and making build/test signal less flaky and more trustworthy. Better savings, better experience.

Most practically for you: we'll go over what can you do in your codebase to improve your testing workflows, ranging from low commitment concepts to high commitment ones. Also importantly: what anti-patterns can you avoid, so that you don't blockade future work in this area.

Our exploration will take us across topics including build tools, how the compiler/linker fits into the story, caching in unexpected places, deciding what to test (in great depth), batching, patterns/anti-patterns for defining workflows, and more. We will talk about real learnings from metric-driven changes to our core continuous integration experiences.
—
Mark Isaacson
Software Engineer, Facebook
Mark Isaacson is a Software Engineer at Facebook, where he works on improving the developer experience for all C++ programmers at Facebook.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
Lambdas — even C++14's mysterious "generic lambdas" — are just syntactic sugar atop constructs that are perfectly understandable when approached from the right direction.

We'll start with the implementation of C-style functions, then move to overloading, function templates, non-static member functions, C++11 lambdas, and then demystify C++14's generic lambdas. We'll cover the minor changes to lambdas in C++17, such as the ability to capture `*this` by value, and indicate some of the minor changes coming in C++2a. Finally, we'll detour into the implementations of std::function and std::bind to show how they're different from lambdas.

Attendees will leave this session with a clear understanding of how C++ — a language without dynamic typing or garbage collection — can nevertheless support efficient lambda closures.
—
Arthur O'Dwyer
New York

Arthur O'Dwyer is the author of "Colossal Cave: The Board Game," "Mastering the C++17 STL" (the book), and "The STL From Scratch" (the training course). He runs professional C++ training courses, is occasionally active on the C++ Standards Committee, and has a blog mostly about C++.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
We say that interfaces should be easy to use and hard to misuse. But how do we get there? In this talk I will demonstrate how using declarative techniques in APIs, functions, and plain old “regular” code can help.

We’ll look at what is meant by “declarative style” in C++; explore why declarative interfaces are desirable and how to construct them; and take an in-depth look at which features of C++ help us write in a declarative style.

I want to deconstruct C++ a bit, examine what we’re doing and what makes the good parts good, and from that reconstruct some best practices. Many of us are already writing code following piecemeal modern advice such as “no raw loops”, or “almost always auto”, or C++ core guideline recommendations. In many cases, this advice translates to writing more declarative code; being deliberate about exploring and using declarative techniques gives us insight we can apply more widely.
—
Ben Deane
Ben was in the game industry for 23 years, at companies like EA and Blizzard. He's always looking for useful new techniques in C++, and he | geeks out on algorithms, APIs, types and functional programming.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
C++17 introduced the std::pmr framework. In this framework, a std::pmr::polymorphic_allocator＜T＞ holds a pointer to a std::pmr::memory_resource. The memory resource is in charge of managing and organizing the heap itself, and the allocator object is just a thin "handle" pointing to the memory resource.

This is not just a convenient implementation strategy for std::pmr! Rather, this elucidates the true meaning of the Allocator concept which has existed, unchanged, since C++98. An Allocator *is* a (value-semantic) handle to an (object-semantic) MemoryResource. Even std::allocator can — and should — be viewed as a handle to a global singleton "heap", and not as a heap itself.

From this core insight we derive many corollaries, such as the need for allocator types to be lightweight and efficiently copyable, the fundamental impossibility of implementing an "in-place" std::vector via stupid allocator tricks, and the philosophical underpinnings of "rebinding."

Time permitting, we'll
- discuss what we can expect from a "moved-from" allocator object
- relate the notion of "handle" to neighboring notions such as "façade" and "adaptor"
- suggest similarities between "allocator/heap" and "executor/execution-context"
—
Arthur O'Dwyer

Arthur O'Dwyer started his career writing pre-C++11 compilers for Green Hills Software; he currently writes C++14 for Akamai Technologies. Arthur is the author of "Colossal Cave: The Board Game," "Mastering the C++17 STL" (the book), and "The STL From Scratch" (the training course). He is occasionally active on the C++ Standards Committee and has a blog mostly about C++.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
C++ is used in a wide variety of platforms and environments, some of which don't provide all of the features described in the C++ Standard. For example, C++ features that require operating system support may be unavailable in low-end embedded systems, or when implementing an operating system itself. To help programmers write highly portable code, the C++ Standard drew a line between the “freestanding” features that should be available everywhere and the “hosted” features that might not. But the line has always been blurry. As C++ continues to develop, more and more developers are asking where and how that line should be drawn.

This session explores the state of freestanding C++. It discusses the history behind freestanding C++, examines how it’s actually used (and not used), and looks at where it might be going in the future.
—
Ben Saks
Chief Engineer, Saks & Associates
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
The history of concurrent programming in C++ is short. It began in 2011. At first peek, C++11, and later C++-standards support only the abstractions for library developers but not for application developers.
But the second view gives more details. Using the right techniques and the right abstraction make it possible to use the concurrent features safely.

This class shows you the safe way:

- How you can use atomics for simple jobs.
- How locks help to master shared state without the inherent danger of mutexes.
- How tasks are a significant improvement to threads and are part of the future and not of the past. Tasks allow you to
* share state without the need of synchronisation.
* manage values, notifications, and exceptions in a concurrent environment.
* create producer/consumer workflows without the highly error-prone condition variables.
- How to use concurrency in a declarative style with the parallel STL.
—
Rainer Grimm
Trainer, Modernes c++
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
With all the new features C++14 and C++17 offer, it can be frustrating to be stuck with an old compiler that doesn't support them yet. Instead of forgoing structured bindings, fold expressions, and other additions, what if we could use them even on pre-2014 compilers?

Enter clang-from-the-future, a transpiler that reads C++17 programs and outputs standard C++11 source code. When used as a preprocessing step, it allows any compiler with C++11 support to compile a subset of C++14/17 programs. To enable this, CTFT rewrites new language features based on the program's abstract syntax tree and provides drop-in implementations for standard library additions.

In this talk, I will show how specifically this is achieved, how well it works in practice, and what's left to be done in the future.

The source code for CFTF can be downloaded here: https://github.com/neobrain/cftf
—
Tony Wasserka, Freelance Software Developer

Low-level anything: Tony is a freelancer and long-term C++ enthusiast who has worked on the console emulator projects Dolphin (GameCube/Wii), PPSSPP (PSP), and Citra (3DS) since 2010. More recently, he has worked on Vulkan graphics drivers for PowerVR graphics processors. His main interest is exploring C++'s zero-cost abstraction capabilities and applying them to create better software for resource-constrained environments.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
In recent years the increased usage of std::function has transformed the way many C++ programs are written. However, if your application is processing realtime data, or doing some other performance critical task, then the possibility of std::function allocating some memory from the heap may not be tolerable. It's also possible that the systems you are targeting simply lack a std::function implementation, preventing its adoption in applications for legacy operating systems, toolchains for embedded devices, and inside open source library code. Rolling your own implementation of std::function can provide a solution to both of these concerns simultaneously, allowing you to modernize your code and provide guarantees about the runtime performance of manipulating function objects.

This presentation outlines why and how a std::function replacement was added to the JUCE open source, cross platform, software development framework and discusses some differences between our implementation and others. We will also cover how we can move beyond the standard interface by extending the small buffer optimization to make manipulating callable objects more suitable for performance critical and realtime contexts, finishing with some examples of how this applies to processing live audio data.
—
Tom Poole, ROLI
Senior Software Developer

Tom Poole (PhD) is a senior software engineer at ROLI Ltd. and a maintainer of the JUCE open source, cross platform, C++ framework ( https://juce.com). Before joining ROLI, he completed his PhD at Imperial College London, developing massively parallel Quantum Monte Carlo algorithms, and simultaneously founded two successful startups, one in big data news aggregation and another in audio processing plug-ins. Tom is a regular speaker and/or workshop leader at the C++ audio developer conference ADC.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
This talk introduces argument dependent lookup(ADL); name taxonomy; and customisation points in order to demonstrate and understand the peculiarities and the process of looking up names with ADL. Furthermore, this talk will demonstrate and discuss ADL thoroughly in the context of templates.

What is ADL?

ADL is a C++ feature that extends a name’s* lookup set by associating it with “extra” namespaces. The C++ standard mandates name taxonomy in a nonintuitive way that makes it difficult for young programmers to understand and use this feature. On the other hand, in advanced use cases of templates even experienced programmers sometimes struggle to reason about their code.

Why ADL?

It greatly enhances the usability of templates by allowing the compiler to extend the overload resolution of a template call allowing it look up more declarations which otherwise would be hidden from the compiler.

Library authors who design generic code don’t know firsthand how the users intent to use the library. Therefore, it’s essential to allow clients to customise the behaviour of their generic code on cases where they believe a more specialised implementation is desired. For instance, a qualified call to std::swap() is condemned to bypass any user defined overload of swap().

*The precise definition will be given in the name taxonomy category section of the outline
—
Kostas Kyrimis
Codeplay Software
Software Engineer

Kostas Kyrimis is a software engineer who is working on ComputeCpp; Codeplay’s implementation of the Khronos Group open standard SYCL for heterogenous computing. He advocates modern C++ practices, appreciates generic programming and algorithms and he is a supporter of expressive, clean and scalable code. Furthermore, Kostas, holds a BSc and MSc in Computer Science and on his free time he enjoys travelling, snowboarding and strength training.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2018
—
Lightning Talk
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
The oft-cited Hyrum's law states that "with a sufficient number of users of an API, it does not matter what you promise in the contract: all observable behaviors of your system will be depended on by somebody." With the introduction of concepts as a language feature in C++20, generic programming is expected to make its way into more layers of software stacks than ever before. Employing concept-driven design across multiple layers of a software stack affords a number of new and innovative approaches to battling Hyrum's law. As more and more libraries are tested and deployed with contracts expressed through generic concepts, a new art of providing models of those concepts that stress the boundaries of the contracts they represent is emerging. Put simply, it's more important than ever to break things early and often.

Unlike interfaces based on concrete types and abstractions, where a single interface is generally tied to a single implementation (thus leading to leaking of implementation details into an implicit interface), concept-driven interface designs can more naturally provide multiple implementations that model a concept, and thus constrain the implicit interface to the overlap of those implementations. Designing and implementing sets of types that minimize this intersection is a crucial skill that should be in every advanced developer's toolbox, and yet it is rare to hear this "art of breaking things" addressed explicitly.

In this talk, we will examine the implementation of several common interfaces that can be expressed with concept-driven design, including ranges, futures, strings, spans, and executors. Within a typical set of contracts for these concept interfaces, we will work through the design and implementation of models for these concepts focused on breaking user code that unsafely widens these contracts. We will further motivate these examples with some real-world scenarios and weigh the importance of breaking things against other factors in generic library design. Finally, we will discuss how the ability to break things should feed back into the concept design process itself, leading to more robust and less implicit interfaces throughout your software stack.
—
David Hollman
Sandia National Labs
Senior Member of Technical Staff
Livermore, California

Dr. David S. Hollman has been involved in the ISO-C++ standard committee since 2016. He has been a part of a number of different papers in that time, including `mdspan`, `atomic_ref`, and—most prominently—executors and futures. Since finishing his Ph.D. in computational quantum chemistry at the University of Georgia in 2013, he has mostly worked on programming models for computational science, data science, and related fields. He joined Sandia National Labs in 2014 and has worked on several different programming models projects since then.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
The ABI (Application Binary Interface) has a huge impact on C++ libraries. But what does that mean concretely?

This talk will explain what we mean by the ABI in the context of C++. Starting from the ground up and focusing on the Itanium C++ ABI specification, we will understand what is part of the ABI and how changes in your C++ source code can result in changes to the ABI. We will also cover what ABI stability means, what use cases ABI stability enables, and what some of the costs of maintaining ABI stability are.

Keeping the point of view of a library implementer, we will see how one can control what is part of a library's ABI, using both standard and non-standard techniques like attributes. Finally, we will also see some tools that can be used to inspect parts of the ABI of a built program and detect changes to it.
—
Louis Dionne
Apple
C++ Standard Library Engineer
Quebec, Canada

Louis is a math and computer science enthusiast who got swallowed by the C++ monster when he was a naive, unsuspecting student. He now works for Apple, where he is responsible for libc++, the Standard Library shipped with LLVM/Clang. He is a member of the C++ Standards Committee and of the Boost community, where he authored the Boost.Hana metaprogramming library.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
There are many ways to initialize an object in C++, and much time spent analyzing the efficiency of the many options. We then think and rethink and overthink how to avoid copies and if a `std::move` would be more efficient in a certain case.

But if we understand what it means for a type to be trivial most of these questions now become meaningless. We can get all of the efficiency we could hope for, and probably more.

We will look at the trivial type traits, what they mean, and how they affect our code. Will will then examine the benefits of using trivial types and the impact on performance.
—
Jason Turner
Developer, Trainer, Speaker
Greater Denver Area

Host of C++Weekly https://www.youtube.com/c/JasonTurner..., Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com.

—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
It's 2019 and Unicode is still barely supported in both the C and C++ standards.

From the POSIX standard requiring a single-byte encoding by default, heavy limitations placed in codecvt facets in C++, and the utter lack of UTF8/16/32 multi-unit conversion functions by the standard, the programming languages that have shaped the face of development from operating systems, embedded devices and mobile applications has pushed forward a world that is incredibly unfriendly to a world of text beyond ASCII. Developers frequently roll their own solutions, and almost every major codebase -- from Chrome to Firefox to Qt to Copperspice and more -- all have their own variations of hand-crafted text processing. With no standard implementation in C++ and libraries split between various third party implementations and ICU, it is increasingly difficult and error-prone to handle what is the basic means of communication between people on the planet using C++, let alone the security holes found in hand-rolled libraries that do not carefully handle this tricky design space.

Small victories for character types that represent UTF8 exclusively, mandated UTF16 and UTF32 encoding for literals, and updating the Unicode Standard Reference in C++ have been accomplished by Study Group 16, who are the Unicode Arm of Standard C++. With the last of the foundational work to the C standards committee underway and participation from individuals at Mozilla, Google, Qt, Microsoft, Bloomberg, and Apple informing the design, Unicode in C++ is planned to be the biggest and best addition of first-class support for Unicode in C++.

This talk is going to be an overview of the problem space -- Text in C++ -- the people who are tackling the problem -- Study Group 16 -- and the first major libraries and works to be produced for handling encoding and normalization both flexibly and efficiently. It will talk about what we learned from its predecessors -- Boost.Text, text_view, ICU and Ogonek -- and what can be reasonably expected for C++23 and what aspirations SG16 has for the future. Come see the new face of a range-friendly encoding, decoding and normalization interfaces in C++.
—
JeanHeyd Meneide
Columbia Unviersity
Student

JeanHeyd "ThePhD" is a student at Columbia University in New York. Most of his programming is for fun and as a hobby, even if his largest open-source contribution -- sol2 -- is used across many industries. He is currently working towards earning his own nickname, climbing the academic ladder while spending as much time as possible contributing to C++ standardization and development.

He very much loves dogs and hopes to have his own in a year or so. He also likes Vulf's "Tee Time" from the album Mr. Finish Line.
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com

http://CppCon.org
—
Discussion & Comments: https://www.reddit.com/r/cpp/
—
Presentation Slides, PDFs, Source Code and other presenter materials are available at: https://github.com/CppCon/CppCon2019
—
The history of concurrent programming in C++ is short. It began in 2011. At first peek, C++11, and later C++-standards support only the abstractions for library developers but not for application developers.
But the second view gives more details. Using the right techniques and the right abstraction make it possible to use the concurrent features safely.

This class shows you the safe way:

- How you can use atomics for simple jobs.
- How locks help to master shared state without the inherent danger of mutexes.
- How tasks are a significant improvement to threads and are part of the future and not of the past. Tasks allow you to
* share state without the need of synchronisation.
* manage values, notifications, and exceptions in a concurrent environment.
* create producer/consumer workflows without the highly error-prone condition variables.
- How to use concurrency in a declarative style with the parallel STL.
—
Rainer Grimm
Trainer, Modernes c++
—
Videos Filmed & Edited by Bash Films: http://www.BashFilms.com