Use the official range-v3 with MSVC 2017 version 15.9—CoderCasey

Everything is in the title.

Use the official range-v3 with MSVC 2017 version 15.9

by CoderCasey

From the article:

We’re happy to announce that the ongoing conformance work in the MSVC compiler has reached a new milestone: support for Eric Niebler’s range-v3 library. It’s no longer necessary to use the range-v3-vs2015 fork that was introduced for MSVC 2015 Update 3 support; true upstream range-v3 is now usable directly with MSVC 2017.

Using STL algorithms with cppcheck—Paul Fultz II

Making the code more expressive.

Using STL algorithms with cppcheck

by Paul Fultz II

From the article:

From Sean Parent’s C++ Seasoning talk, he explains how raw loops suffer from several issues:

  • Difficult to reason about and difficult to prove post conditions
  • Error prone and likely to fail under non-obvious conditions
  • Introduce non-obvious performance problems
  • Complicates reasoning about the surrounding code

Instead algorithms should be preferred, either using the algorithms in the standard library or writing a new algorithm. Even more so, Sean Parent suggests that all coding guildines should be replaceed with “No raw loops” in order to improve code quality...

Exploring Clang Tooling Part 3: Rewriting Code with clang-tidy—Stephen Kelly

The series continue.

Exploring Clang Tooling Part 3: Rewriting Code with clang-tidy

by Stephen Kelly

From the article:

In the previous post in this series, we used clang-query to examine the Abstract Syntax Tree of a simple source code file. Using clang-query, we can prototype an AST Matcher which we can use in a clang-tidy check to refactor code in bulk.

This time, we will complete the rewriting of the source code...

Introducing Conduit for C++: Lazy Sequences Using the Coroutine TS—Buckaroo

It is worth looking at it.

Introducing Conduit for C++: Lazy Sequences Using the Coroutine TS

by Buckaroo

From the article:

Conduit is a new library that leverages the Coroutine TS to introduce lazy sequences to C++.

Lazy sequences are an idea that’s very popular in the functional-programming community, but less common in the C++ world.

Simply put, a lazy sequence is one where the elements are computed as they are requested, rather than in advance.
This can lead to big efficiency gains since you only perform the computation required. It also allows you to represent infinite sequences, which of course could never fit into a vector!

Let’s see how Conduit works with some simple examples…

Pacific++ 2018: C++ Past vs. Future—Titus Winters

Did you see it?

Pacific++ 2018: C++ Past vs. Future

by Titus Winters

From the video:

Over the last 35 years, C++ has remained a constant fixture in the programming landscape. With advancements in the language through C++11, 14, and 17, we've created new dialects that have breathed new life into C++. With C++ Core Guidelines and a rich community of authors and speakers providing guidance on C++, it is easier now to steer clear of problem areas and hopefully stay in the "good parts" of the language.
Or at least, that's what we'd like. In practice, many habits of C++ programmers are unsafe and will be hard to keep working. The triple perils of ADL, ODR, and ABI leave a wide assortment of pitfalls for code maintenance. Many systems happen to work, but perhaps more out of luck than actual correctness.
How do we explain this dichotomy? How is the language better than it ever has been, and at the same time so dangerous and burdened with silent pitfalls and legacy? Can the standard evolve over time to reduce these perils? More importantly: should it?
In this talk I'll remind people of how precarious most C++ code is in the face of change (like advancing to a new language version), and discuss the most fundamental issue facing the committee these days: how to balance between the legacy code of the past and the yet-to-be-written code of the future.

C++ On Sea: Full schedule now available

The schedule for the new C++ On Sea conference is now available:

Full schedule now available

by C++ On Sea

From the announcement:

We're thrilled to announce that the full schedule for the conference has now been finalised and published. Of course, when I say, "finalised", that doesn't mean it definitely won't change again, but I don't expect much movement.

You'll notice that day two (Tuesday) has four tracks. As mentioned before, the response was so great that we felt we had to put on an extra track. Note, also, the Lightning Talks at the end of day one. We'll take submissions for that closer to the time of the conference - or at the conference.



Five Awesome C++ Papers for San Diego—Bartlomiej Filipek

What do you think?

Five Awesome C++ Papers for San Diego

By Bartlomiej Filipek

From the article:

In two weeks there will be a next C++ Committee meeting. This time the group of C++ experts will travel to San Diego, and they will discuss the shape of the upcoming C++ Standards. As far as I know, the meeting will hold a record in the number of submissions (276 proposals!) So it seems that the session will be quite exhausting smile

Here’s my list of five exciting papers that will be discussed during the meeting. I tried to pick something less popular, and usually smaller than significant features like modules, concepts or ranges...

Exploring Clang Tooling Part 2: Examining the Clang AST with clang-query—Stephen Kelly

The series continue.

Exploring Clang Tooling Part 2: Examining the Clang AST with clang-query

by Stephen Kelly

From the article:

In the last post, we created a new clang-tidy check following documented steps and encountered the first limitation in our own knowledge – how can we change both declarations and expressions such as function calls?

In order to create an effective refactoring tool, we need to understand the code generated by the script and learn how to extend it.

Exploring Clang Tooling Part 1: Extending Clang-Tidy—Stephen Kelly

A very useful tool.

Exploring Clang Tooling Part 1: Extending Clang-Tidy

by Stephen Kelly

From the article:

This post is part of a three-part series about using the Clang AST Matchers to mechanically refactor C++ code. In the last post, we ensured that the code is at least buildable with Clang. While that part was only interesting to those whose code was not yet building with Clang, the rest of the series appeals to a general C++ audience.

There are many other resources on the internet covering use of existing clang-tidy checks and their motivation, such as my previous employer. There is very little information online about the developer workflow and tools to use when creating custom extensions for source to source transformations with clang-tidy. This blog series aims to fill that gap.