community : Standard C++

Home » Blog » Tags » community

« Prev Next »

community

Cppcon 2021 C++20’s ＜chrono＞ Calendars and Time Zones in MSVC--Miya Natsuhara

By Adrien Hamelin | Oct 12, 2021 12:10 PM | Tags: community

Registration is now open for CppCon 2021, which starts on October 24 and will be held both in person and online. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2021 to attend in person, online, or both!

C++20’s ＜chrono＞ Calendars and Time Zones in MSVC

Thursday, October 28 • 10:30am - 11:30am

by Miya Natsuhara

Summary of the talk:

The ＜chrono＞ header has existed since C++11, but C++20 dramatically increased its capabilities. MSVC has completed this C++20 feature and this session will focus on the development of our implementation and Windows-specific considerations that we encountered. For instance, how do we know if a given point in time is during a leap second insertion? Where do we get the data for time zones? If you are excited by these new chrono features and want to support a Windows platform, come and learn about its developments and caveats for a Windows implementation!

We will also touch on how STL maintainers and our valued external contributors developed the new features collaboratively. If you’re interested in participating in our open-source repo by reporting issues, contributing to discussions, or submitting pull requests, we hope that hearing about an example of collaboration will encourage you to visit our repo in the future.

Cppcon 2021 From Problem to Coroutine: Reducing I/O Latency--Cheinan Marks

By Adrien Hamelin | Oct 11, 2021 12:54 PM | Tags: community

From Problem to Coroutine: Reducing I/O Latency

Wednesday, October 27 • 10:30am - 11:30am

by Cheinan Marks

Summary of the talk:

Coroutines are now officially part of the C++20 standard and one of their advertised uses is reducing I/O latency. Almost all of the literature on coroutines that I found illustrated either synchronous generators or described the nitty gritty details of coroutines using very simple usages. The best talk I found was Gor Nishanov's excellent talk from CppCon 2018, "Nanocoroutines to the Rescue!" (go watch it!) which solves a different problem than mine, but mostly illustrates the power of coroutines.

In this talk I want to approach coroutines from another direction. I will start with the problem, which almost all engineers face in some form, that of reducing I/O latency while searching and gathering data from a sequential file. Instead of going into the details of how the coroutines work, I will start with the naive synchronous solution and build up coroutines step by step to try and reduce latency, illustrating the pieces as they are added.

Finally I will compare this solution to an old-fashioned solution using threads and we'll see how the coroutines performance measures up and whether all the additional boilerplate needed is worth the additional trouble. I hope discussing the value of coroutines and future proposals for RAII and executors will spark a good discussion with the audience.

Improved Null Pointer Dereference Detection in Visual Studio 2022 version 17.0...--Gabor Horvath

By Adrien Hamelin | Oct 11, 2021 12:47 PM | Tags: community

Give it a try!

Improved Null Pointer Dereference Detection in Visual Studio 2022 version 17.0 Preview 4

by Gabor Horvath

From the article:

The C++ static analysis team is committed to making your C++ coding experience as safe as possible. We are adding richer code safety checks and addressing high impact customer feedback bugs posted on the C++ Developer Community page. Thank you for engaging with us and giving us great feedback on the past releases and early previews leading to this point. Below is the detailed overview of a new experimental code analysis check that can detect null pointer dereference errors, along with a comparison to an existing check that has the same purpose...

Cppcon 2021 Embracing PODs Safely Until They Die--Alisdair Meredith and Nina Ranns

By Adrien Hamelin | Oct 8, 2021 01:06 PM | Tags: community

Embracing PODs Safely Until They Die

Thursday, October 28 • 10:30am - 11:30am

by Alisdair Meredith and Nina Ranns

Summary of the talk:

How do you change the active member of a union? Can you copy an object without
a publicly callable copy constructor? Can you pass classes having private data to
a function implemented in C? What is the use case for the library type trait
`std::is_trivially_move_assignable`? All these questions and more will be answered
in this session.

PODs --- Plain Old Data --- are neither plain nor old in C++11, and continued to
evolve in every published standard since, until they were finally banished in C++20.
In researching the deconstruction of PODs for the upcoming book, "Embracing
Modern C++ Safely" Alisdair Meredith (and the other authors including John
Lakos, Vittorio Romeo, and Rostislav Khlebnikov) discovered that many of the
intuitive properties and capabilities of trivial and standard layout types did not
behave quite as expected, and there are many subtleties waiting to catch the
unwary. Nina Ranns, as an active member of the Core working group, stepped in
to explain and resolve many concerns, while pointing out further bad assumptions.
Together they will present the use cases, pitfalls, and annoyances of these features
as now properly understood, giving a flavor of the presentation style of each of the
57 C++11/14 features presented in the book.

Compiler Explorer with Cmake--Gajendra Gulgulia

By Adrien Hamelin | Oct 8, 2021 01:03 PM | Tags: community

New capabilities.

Compiler Explorer with Cmake

by Gajendra Gulgulia

From the article:

Compiler explorer has been one of the most widely used online tool for compiling C++ code, doing experiment with C++ features, sharing code snippets with friends and colleagues and also (my favorite feature) to compare and prove with the help of assembly code why a certain way of coding might be good or bad compared to another way.
Recently compiler explorer added support for compiling multiple files with CMakeLists.txt [1] . This opens up a new possibilities for developers around the world from testing complex pieces of code to testing the compilation behavior of the same.
In this issue, I would like to give a walk through on how to set up a simple layout of three files compiled with CMakelists.txt. Note that the focus is on setting up compiler explorer for multiple files and not on code efficiency. Also the article might at first glance look lengthy, but it may only be due to 19 images in the tutorial. So don’t get weighed down by the size of the article and lets start!

Cppcon 2021 What You Can Learn from Being Too Cute: Why You Should Write Code That...--Daisy Hollman

By Adrien Hamelin | Oct 7, 2021 09:31 AM | Tags: community

What You Can Learn from Being Too Cute: Why You Should Write Code That You Should Never Write

Friday, October 29 • 1:30pm - 2:30pm

by Daisy Hollman

Summary of the talk:

During the COVID-19 global pandemic, as we all searched for ways to stay connected to the C++ community, I innocently started posting short, 25-line or less C++ snippets of counterintuitive C++ code that I called my "Cute C++ trick of the day." I was floored by the amount of attention these tweets received, with some being viewed more than 30,000 times and liked or retweeted hundreds of times. I received repeated requests to collect these tricks into a library or talk, and this is that talk.

In this presentation, I will dissect a few of my most popular "Cute C++ tricks" to a level of detail not possible on social media platforms like Twitter. I'll talk about how and why these tricks work the way they do, talk about the dark corners of C++ they touch upon, and talk about what you should actually do if you need to produce the same effect in production code. While not targeted at beginners, these tricks span the gauntlet from features that most intermediate programmers are aware of (but never thought to use in a particular way) to dark corners of the language that many of my C++ committee colleagues were surprised to learn about. Throughout it all runs a common thread: learning how to exploit your own curiosity to expand your toolbox, gain a better grasp of the fundamentals of C++, and ultimately, become a better programmer.

Cppcon 2021 A (Short) Tour of C++ Modules--Danila Kutenin

By Adrien Hamelin | Oct 5, 2021 11:33 AM | Tags: community

A (Short) Tour of C++ Modules

Tuesday, October 26 • 3:15pm - 4:15pm

by Danila Kutenin

Summary of the talk:

Once you decide to start a big project or a company, it eventually comes down to unifying the build infrastructure. However, hundreds and thousands of compilation units are extremely difficult to maintain to achieve the highest possible performance. Contrary to the belief that you should always trust your compiler, recent micro-architectural breakthroughs from merging two arrays with special instructions to JSON parsing through SIMD showed that compilers are far from understanding every single piece of code you write. In this session we will talk about our experience on how to achieve the highest possible performance without much rewriting of your code, which trade-offs C++ compilers have, how to make the most of your micro-architecture, why unrelated changes may decrease the performance and how to debug them. In the end we will show which compiler options gave us the opportunity to gain 5-15% of performance, stabilized the benchmarks and decreased the build size for search engines, databases and high performance computing.

Cppcon 2021 Back To Basics: Overload Resolution--Barbara Geller and Ansel Sermersheim

By Adrien Hamelin | Oct 4, 2021 01:36 PM | Tags: community

Back To Basics: Overload Resolution

Tuesday, October 26 • 9:00am - 10:00am

by Barbara Geller and Ansel Sermersheim

Summary of the talk:

During this talk we will explain the definition of a function overload and what rules the compiler follows to decipher which overload to call. The rules can be complex and may not always do what you expect. We will condense the C++ standard to the essential rules every programmer should be aware of in order to reason through overload resolution.

Knowing how overload resolution works will improve your ability to debug compiler errors and this is vital to write correct code. We will provide simple and concise explanations for various buzzwords like template argument deduction, implicit conversion, standard conversions, and tie-breakers.

This talk is part of the Back to Basics track and the material will be targeted to include all skill levels. Familiarity with C++ is recommended however no prior knowledge of function overloads is required.

C++ Russia 2021 Conference

By Anna Kurilo | Oct 4, 2021 11:05 AM | Tags: community

C++ Russia, 15 Nov - 18 Nov is a conference with several tracks of in-depth technical talks devoted to C++.

C++ Russia

About the conference

The conference covers topics like

concurrency;

performance;

architecture;

infrastructure solutions.

All you need to make your code more concise and productive.

Among speakers:

Titus Winters, Google;

Phil Nash, SonarSource;

Anton Polukhin, Yandex Go;

Denis Yaroshevskiy, Bloomberg.

You can view the list of speakers and the first program on the website.

CppCon 2021 Code Analysis++--Anastasia Kazakova

By Adrien Hamelin | Oct 1, 2021 02:59 PM | Tags: community

Code Analysis++

Tuesday, October 26 • 7:45am - 8:45am

by Anastasia Kazakova

Summary of the talk:

Martin Fowler once wrote that high-quality software is actually cheaper to produce than low-quality software. We agree with that sentiment, and we warmly welcomed the C++ Core Guidelines when they were introduced in 2015. Research and surveys conducted in the C++ Community consistently demonstrate the popularity of the Clang family of tools, as well as the growing demand for static analysis to be added to code editors.

In this talk, we’ll explore the current capabilities of existing C++ static analyzers and discuss some of the enforcements listed in the C++ Core Guidelines from a toolability aspect. We’ll also look into the recent “Simplify C++” trend in the language’s evolution, and to wrap things up we’ll take a look at how technology-specific analysis (like MISRA and AUTOSAR) is being adopted.

A variety of checks will be discussed, from catching a dangling pointer to conforming to the preferred code style and naming scheme. And I want to share a crazy idea I have about gamifying static analysis. Let’s play!