Better C++14 reflections - Antony Polukhin - Meeting C++ 2018 https://www.youtube.com/watch?v=UlNUNx
First talk from Meeting C++ is released:
Better C++14 reflections
by Antony Polukhin
Exploring C++20 - Class Types in Non-Type Template Parameters--Tobias Widlund
Exciting!
Exploring C++20 - Class Types in Non-Type Template Parameters
by Tobias Widlund
From the article:
If I had to pick out my favourite features planned for C++20, then this one would definitely be amongst the top 5 since I love compile time programming. This feature makes it more natural to write templated code since it allows you to group data together and pass it to a template without having to resort to hacks.
To explain what this feature is about, I will start by talking about normal non-type template parameters from pre-C++20...
The pImpl Idiom--Arne Mertz
In one word.
The pImpl Idiom
by Arne Mertz
From the article:
The pImpl idiom is a useful idiom in C++ to reduce compile-time dependencies. Here is a quick overview of what to keep in mind when we implement and use it...
Don’t pass lambdas (or other multi-line entities) as parameters to macros--Raymond Chen
Not helping you.
Don’t pass lambdas (or other multi-line entities) as parameters to macros
by Raymond Chen
From the article:
Consider this macro:
#ifdef DEBUG #define LOG(value) LogValue(value) #else // In production, evaluate but don't log. #define LOG(value) (value) #endifThis seems not entirely unreasonable, but bad things happen if you pass a multi-line entity as the macro parameter...
Move smart pointers in and out functions in modern C++
Different options with different meanings.
Move smart pointers in and out functions in modern C++
by Triangles @ Internal Pointers
From the article:
Passing and returning smart pointers to/from functions are operations that require some planning. There are many ways of doing it and picking the right one is not always straightforward. Luckily for us C++ experts have guidelines that shed some light on this task.
Modern dining philosophers -- Lucian Radu Teodorescu
How to solve the dining philosophers problem in 2018? By using tasks. And how to use tasks? Read on...
Modern dining philosophers
by Lucian Radu Teodorescu
From the article:
We give several solutions to the dining philosophers problem, each with some pros and cons. But, more importantly, we walk the reader through the most important aspects of using tasks to solve concurrency problems.
Instead of reaching for our higher-level frameworks, we opted to keep the level of abstractions as close as possible to raw tasks. This way, we hope to guide the reader to understand more about the essence of task-based programming. Our aim is to make the reader comprehend the machinery of composing tasks; those skills should be highly valuable.
C++17: std::scoped_lock--Marc Gregoire
Short and clear.
C++17: std::scoped_lock
by Marc Gregoire
From the article:
C++17 includes an std::scoped_lock (defined in <mutex>) which basically replaces std::lock_guard...
The overview of C++20 Range view--Ryou Ezoe
Simple, good.
The overview of C++20 Range view
by Ryou Ezoe
From the article:
The latest C++ draft at the time of writing incorporated The One Ranges Proposal.
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4791.pdf
So what is a Range, anyway? The C++ Standard Comittee member, Eric Niebler, summarised it well in this article:
Eric Niebler – Eric Niebler
Actually, he summarised it all too well to the point that his code became almost unreadable to an average C++ programmer. One might say, it's practically useless. So this article serves as a quick tutorial for the Range view...
50 shades of C++ - Nicolai Josuttis - Meeting C++ 2018 Closing Keynote
Nicolai Josuttis gave a fantastic closing keynote at Meeting C++ 2018
50 shades of C++
by Nicolai Josuttis
Call For Papers: Distributed & Heterogeneous Programming in C/C++
The call for papers is now open for DHPCC++19 and closes on 27th January.
DHPCC++, 13 May 2019, Northeastern University, Boston, USA
by the DHPCC++
From the article:
This will be the 3rd DHPCC++ event in partnership with IWOCL, the international OpenCL workshop with a focus on heterogeneous programming models for C and C++, covering all the programming models that have been designed to support heterogeneous programming in C and C++.
Many C++ programming models exist including SYCL, HPX, KoKKos, Raja, C++AMP, HCC, Boost.Compute, and CUDA. This conference aims to address the needs of both HPC and the consumer/embedded community where a number of C++ parallel programming frameworks have been developed to address the needs of multi-threaded and distributed applications. The C++11/14/17 International Standards have introduced new tools for parallel programming to the language, and the ongoing standardization effort is developing additional features which will enable support for heterogeneous and distributed parallelism into ISO C++ 20/23. This conference is an ideal place to discuss research in this domain, consolidate usage experience, and share new directions to support new hardware and memory models with the aim of passing that experience to ISO C and C++.
Topics of interest include, but are not limited to:
- Future Heterogeneous programming C/C++ proposals (SYCL, Kokkos, Raja, HPX, C++AMP, Boost.Compute, CUDA …)
- ISO C/C++ related proposals and development including current related concurrency, parallelism, coroutines, executors
- C/C++ programming models for OpenCL
- Language Design Topics such as parallelism model, data model, data movement, memory layout, target platforms, static and dynamic compilation
- Applications implemented using these models including Neural Network, machine vision, HPC, CFD as well as exascale applications
- C/C++ Libraries using these models
- Integration of these models with other programming models
- Compilation techniques to optimize kernels using any of (clang, gcc, ..) or other compilation systems
- Performance or functional comparisons between any of these programming models
- Implementation of these models on novel architectures (FPGA, DSP, …) such as clusters, NUMA and PGAS
- Using these models in fault-tolerant systems