Online Concurrency Classes--Anthony Williams
Will you attend?
Online Concurrency Classes
by Anthony Williams
From the article:
With all the restrictions brought upon us by COVID-19, many C++ conferences are moving online...
Events
CppCon 2020 Embedded Track--Ben Saks
Will you attend?
CppCon 2020 Embedded Track
by Ben Saks
From the article:
Every year, CppCon offers C++ programmers a chance to exchange ideas with the rest of the C++ community. With the growing interest in autonomous vehicles, wearable devices, and IoT, embedded systems programming makes up an ever larger part of the community. In 2020, CppCon will expand on its past coverage of embedded topics by offering its first official Embedded Track...
Meeting C++ is looking for Sponsors!
Meeting C++ is looking for sponsors for Meeting C++ 2020 in November
Meeting C++ is looking for sponsors!
by Jens Weller
From the article
With Meeting C++ 2020 slowly taking shape, I decided to also make sponsoring of this years conference available!
CppCon 2019: Writing Safety Critical Automotive C++ Software for AI Hardware--Michael Wong
This year, CppCon 2020 is going virtual. The dates are still the same – September 14-18 – and we are aiming for the CppCon live event to have pretty much everything you’re familiar with at CppCon except moved online: multiple tracks including “back to basics” and a new “embedded” track; live speaker Q&A; live talk time zones friendly to Americas and EMEA (and we’re going to try to arrange around-the-clock recorded repeats in all time zones, where speakers who are available can be available for live Q&A in their repeated talks too, and we’ll do that if it’s possible – but we’re still working on it!); virtual tables where you can interact face-to-face online with other attendees just like at the physical event; virtual exhibitor spaces where you can meet the folks on your favorite product’s teams to ask them question face-to-face; pre- and post-conference classes; and even the CppCon house band playing live before every plenary session. All talk recordings will be freely available as usual on YouTube a month or two after the event, but everything else above will be available only live during CppCon week.
To whet your appetite for this year’s conference, here’s another of the top-rated talks from last year. Enjoy – and register today for CppCon 2020 – all the spirit and flavor of CppCon, this year all virtual and online!
Writing Safety Critical Automotive C++ Software for High Performance AI Hardware
by Michael Wong
Summary of the talk:
How can we make C++ in a Safe and secure way?
It is about time we talk about what it takes to create safe software, especially for automotive. This talk is about the practical engineering challenges of turning deep learning, classical machine vision and sensor fusion algorithms from research prototypes into real-world automotive-grade systems. We will summarize the many safety critical standards in general for C++ and specifically for autonomous vehicles (AV). These include the updates to MISRA, AUTOSAR, and our own SG12 which has been processing updates from WG23 for C++. We have been working hard in these standards bodies and with industrial partners to deliver automotive-grade, safe, high performance AI software development tools.
We will further review C++ Directions that supports this and reveal the road map for what is possibly the earliest Safety Critical C++ that is also capable of heterogeneous dispatch for AV.
CppCon 2020 Back to Basics Track--Arthur O'Dwyer
Will you attend?
CppCon 2020 Back to Basics Track
by Arthur O'Dwyer
From the article:
In 2020, as in 2019, CppCon will have a Back to Basics Track. This track’s mission is to cover all the essentials of modern C++. Each session in the track is about a single concrete topic, often expressible in just one or two words: Templates. Exception-safety. Move semantics. Our goal is to fit these sessions together like jigsaw pieces to produce a track that covers “everything you need to know” to be a working programmer in today’s C++ community...
CppCon 2019: Floating-Point ＜charconv＞: Making Your Code 10x Faster With C++17's Final Boss--STL
This year, CppCon 2020 is going virtual. The dates are still the same – September 14-18 – and we are aiming for the CppCon live event to have pretty much everything you’re familiar with at CppCon except moved online: multiple tracks including “back to basics” and a new “embedded” track; live speaker Q&A; live talk time zones friendly to Americas and EMEA (and we’re going to try to arrange around-the-clock recorded repeats in all time zones, where speakers who are available can be available for live Q&A in their repeated talks too, and we’ll do that if it’s possible – but we’re still working on it!); virtual tables where you can interact face-to-face online with other attendees just like at the physical event; virtual exhibitor spaces where you can meet the folks on your favorite product’s teams to ask them question face-to-face; pre- and post-conference classes; and even the CppCon house band playing live before every plenary session. All talk recordings will be freely available as usual on YouTube a month or two after the event, but everything else above will be available only live during CppCon week.
To whet your appetite for this year’s conference, here’s another of the top-rated talks from last year. Enjoy – and register today for CppCon 2020 – all the spirit and flavor of CppCon, this year all virtual and online!
Floating-Point ＜charconv＞: Making Your Code 10x Faster With C++17's Final Boss
by Stephan T. Lavavej
Summary of the talk:
Floating-point numbers are ancient, mysterious, and terrifying. Over the past 30 years, the C and C++ Standards have provided many functions for floating-point/string conversions, such as C's strtof(), strtod(), and printf() %a %e %f %g, and C++'s iostreams, stof(), stod(), and to_string(). Despite this history, floating-point is far from a solved problem - these functions have ranged from annoyingly to egregiously slow, and application developers and library maintainers alike have found it exceedingly difficult to understand floating-point behavior.
This session will present new and wondrous developments in the area of floating-point conversions. If your serialization code is bottlenecked by floating-point printing, this will accelerate your code by roughly 3x to 30x (yes, times, not percent). You can also improve the human-readability of your output. Along the way, this session will cover the basics of floating-point representations, dispelling common myths like fuzziness and non-determinism.
Specifically, C++17 added 3 pages of Standardese describing the charconv header and its functions from_chars() and to_chars(). This feature has required an unexpectedly large amount of implementation work, taking over a dev-year for MSVC and becoming the last C++17 library feature to ship. Coincidentally, Ulf Adams at Google developed a novel algorithm named Ryu, which is responsible for the amazing speed of to_chars(). This session will focus on how to use charconv and how to understand its many supported formats, with a brief overview of Ryu's techniques.
CppCon 2019: Mesh: Automatically Compacting Your C++ Application's Memory--Emery Berger
This year, CppCon 2020 is going virtual. The dates are still the same – September 14-18 – and we are aiming for the CppCon live event to have pretty much everything you’re familiar with at CppCon except moved online: multiple tracks including “back to basics” and a new “embedded” track; live speaker Q&A; live talk time zones friendly to Americas and EMEA (and we’re going to try to arrange around-the-clock recorded repeats in all time zones, where speakers who are available can be available for live Q&A in their repeated talks too, and we’ll do that if it’s possible – but we’re still working on it!); virtual tables where you can interact face-to-face online with other attendees just like at the physical event; virtual exhibitor spaces where you can meet the folks on your favorite product’s teams to ask them question face-to-face; pre- and post-conference classes; and even the CppCon house band playing live before every plenary session. All talk recordings will be freely available as usual on YouTube a month or two after the event, but everything else above will be available only live during CppCon week.
To whet your appetite for this year’s conference, here’s another of the top-rated talks from last year. Enjoy – and register today for CppCon 2020 – all the spirit and flavor of CppCon, this year all virtual and online!
Mesh: Automatically Compacting Your C++ Application's Memory
by Emery Berger
Summary of the talk:
Programs written in C++ can suffer from serious memory fragmentation, leading to low utilization of memory, degraded performance, and application failure due to memory exhaustion. This talk introduces Mesh, a plug-in replacement for malloc that, for the first time, eliminates fragmentation in unmodified C++ applications through compaction. A key challenge is that, unlike in garbage-collected environments, the addresses of allocated objects in C++ are directly exposed to programmers, and applications may do things like stash addresses in integers, and store flags in the low bits of aligned addresses. This hostile environment makes it impossible to safely relocate objects, as the runtime cannot precisely locate and update pointers. Mesh combines novel randomized algorithms with widely-supported virtual memory operations to provably reduce fragmentation, breaking long-established worst-case bounds on memory efficiency with high probability. Mesh generally matches the runtime performance of state-of-the art memory allocators while reducing memory consumption and eliminating pathological cases; in particular, Mesh reduces the memory of consumption of Firefox by 16% and Redis by 39%. There are efforts underway to incorporate Mesh's approach to eliminate fragmentation into existing allocators like tcmalloc and jemalloc; Mesh itself is available at https://github.com/plasma-umass/Mesh, and it can be used just by setting an environment variable.
Introducing ACCU Online - A Local Group With a Global Reach--Bob Schmidt
Will you attend?
Introducing ACCU Online - A Local Group With a Global Reach
by Bob Schmidt
From the article:
ACCU London is proud to host an ACCU Online event - a rescheduling of Chris Oldwood's previously cancelled "A Test of Strength" talk.
The event will be hosted virtually, on Remo. This will also give us the social and networking aspect of meet-ups that we miss from the in-person version.
When: Wednesday, 12th August 2020, 19:00 start...
CppCon 2019: C++20: The small things--Timur Doumler
This year, CppCon 2020 is going virtual. The dates are still the same – September 14-18 – and we are aiming for the CppCon live event to have pretty much everything you’re familiar with at CppCon except moved online: multiple tracks including “back to basics” and a new “embedded” track; live speaker Q&A; live talk time zones friendly to Americas and EMEA (and we’re going to try to arrange around-the-clock recorded repeats in all time zones, where speakers who are available can be available for live Q&A in their repeated talks too, and we’ll do that if it’s possible – but we’re still working on it!); virtual tables where you can interact face-to-face online with other attendees just like at the physical event; virtual exhibitor spaces where you can meet the folks on your favorite product’s teams to ask them question face-to-face; pre- and post-conference classes; and even the CppCon house band playing live before every plenary session. All talk recordings will be freely available as usual on YouTube a month or two after the event, but everything else above will be available only live during CppCon week.
To whet your appetite for this year’s conference, here’s another of the top-rated talks from last year. Enjoy – and register today for CppCon 2020 – all the spirit and flavor of CppCon, this year all virtual and online!
C++20: The small things
by Timur Doumler
Summary of the talk:
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!
CppCon 2019: A Unifying Abstraction for Async in C++--Eric Niebler, David Hollman
This year, CppCon 2020 is going virtual. The dates are still the same – September 14-18 – and we are aiming for the CppCon live event to have pretty much everything you’re familiar with at CppCon except moved online: multiple tracks including “back to basics” and a new “embedded” track; live speaker Q&A; live talk time zones friendly to Americas and EMEA (and we’re going to try to arrange around-the-clock recorded repeats in all time zones, where speakers who are available can be available for live Q&A in their repeated talks too, and we’ll do that if it’s possible – but we’re still working on it!); virtual tables where you can interact face-to-face online with other attendees just like at the physical event; virtual exhibitor spaces where you can meet the folks on your favorite product’s teams to ask them question face-to-face; pre- and post-conference classes; and even the CppCon house band playing live before every plenary session. All talk recordings will be freely available as usual on YouTube a month or two after the event, but everything else above will be available only live during CppCon week.
To whet your appetite for this year’s conference, here’s another of the top-rated talks from last year. Enjoy – and register today for CppCon 2020 – all the spirit and flavor of CppCon, this year all virtual and online!
A Unifying Abstraction for Async in C++
by Eric Niebler, David Hollman
Summary of the talk:
Async in C++ is in a sad state. The standard tools -- promises, futures, threads, locks, and std::async -- are either inefficient, broken, or both. Even worse, there is no standard way to say _where_ work should happen. Parallel algorithms, heterogeneous computing, networking & IO, reactive streams, and more: all critically important foundational technologies that await a standard abstraction for asynchronous computation.
In this talk, Eric Niebler and David Hollman dig into the Standard Committee's search for the basis operations that underpin all asynchronous computation: the long-sought Executor concept. The latest iteration of Executors is based on the Sender/Receiver programming model, which provides a generalization of many existing paradigms in asynchronous programming, including future/promise, message passing, continuation passing, channels, and the observer pattern from reactive programming. It also has surprising and deep connections to coroutines, which further demonstrates the model’s potential to be a truly unifying abstraction for asynchronous programming in C++20 and beyond.
Eric and David will present the short-term and long-term directions for Executors in ISO Standard C++, illustrating the design by walking through several implementation examples. They will talk about the direct connection between coroutines and the Sender/Receiver model and discuss what it means for the future of asynchronous APIs in C++. Finally, they will cover how the restrictions imposed by the Executors model should affect the way you write code today so your code is ready for the next big revolution in parallel and concurrent C++ programming.