Home » Blog » Tags » community

community

Overload 144 is now available

By Adrien Hamelin | Aug 13, 2018 11:33 AM | Tags: community

ACCU’s Overload journal of August 2018 is out. It contains the following C++ related articles.

Overload 146 is now available

From the journal:

Should I Lead by Example?
Stuck on a problem? Frances Buontempo considers where to turn to for inspiration.

Cache-Line Aware Data Structures.
Structuring your program to consider memory can improve performance. Wesley Maness and Richard Reich demonstrate this with a producer-consumer queue.

miso: Micro Signal/Slot Implementation.
The Observer pattern has many existing implementations. Deák Ferenc presents a new implementation using modern C++ techniques.

(Re)Actor Allocation at 15 CPU Cycles.
(Re)Actor serialisation requires an allocator. Sergey Ignatchenko, Dmytro Ivanchykhin and Marcos Bracco pare malloc/free down to 15 CPU cycles.

How to Write a Programming Language: Part 2, The Parser.
We’ve got our tokens: now we need to knit them together into trees. Andy Balaam continues writing a programming language with the parser.

Compile-time Data Structures in C++17: Part 1, Set of Types.
Compile time data structures can speed things up at runtime. Bronek Kozicki details an implementation of a compile time set.

CppCon 2017: Enough x86 Assembly to Be Dangerous--Charles Bailey

By Adrien Hamelin | Aug 6, 2018 01:39 PM | Tags: community

Have you registered for CppCon 2018 in September? Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

Enough x86 Assembly to Be Dangerous

by Charles Bailey

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

This tutorial is an introduction to x86 assembly language aimed at C++ programmers of all levels who are interested in what the compiler does with their source code.

C++ is a programming language that cares about performance. As with any technology, a deep understanding of C++ is helped by knowledge of the layer below, and this means knowledge of assembly language. Knowing what the compiler does with your source code and the limitations under which it operates can inform how you design and write your C++.

We learn how to generate, inspect and interpret the assembly language for your C++ functions and programs. We take a short tour of common assembly instructions and constructs, and discover why extreme caution should be exercised if we are trying to infer performance characteristics from a simple inspection of assembly code.

Starting with a simple `operator+` for a user-defined class, we take a look at how interface and implementation choices affect the generated assembly code and observe the effect of copy elisions and related optimizations that compilers commonly perform.

CppCon 2017: How to Write Effective Documentation for C++ Libraries...--Robert Ramey

By Adrien Hamelin | Aug 3, 2018 01:18 PM | Tags: community

Have you registered for CppCon 2018 in September? Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

How to Write Effective Documentation for C++ Libraries...

by Robert Ramey

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

With the success of GitHub, everybody and his brother is a library developer. Programmers love to create code, upload it to GitHub and hope for immortality. Most projects get only the most cursory examination before being passed over by users. Why is that? GitHub considered the problem.

GitHub just published its 2017 Open Source Survey. The popular social coding service surveyed over 5,500 members of its community, from over 3,800 projects on github.com. It also spoke to 500 coders working on projects from outside the GitHub ecosystem. The Open Source Survey asked a broad array of questions. One that caught my eye was about problems people encounter when working with, or contributing to, open source projects. An incredible 93 percent of people reported being frustrated with “incomplete or confusing documentation”. see https://thenextweb.com/dd/2017/06/02/...

Even the most experienced and dedicated software developers can't do it. This can be confirmed by looking over recent reviews of Boost libraries. The most common complaint is that the documentation isn't useable.

Programmers love their stuff and hope to get people to use it, why don't they fix their documentation? The reason is simple: They don't know how.

Problems

a) It's tedious and boring to write
b) Developers don't know what to include and what to exclude
c) Tools make things harder
d) Regardless of the amount of effort invested, the end result is usually of little or no value.

This presentation will present a "Cookbook" and demonstration for creating documentation. Using this method will

a) Much diminish the tedium of the task.
b) Help improve to the quality of library design and implementation
c) Create something that is useful to the library user.

We will touch upon tools like Doxygen, etc. But this is only a small portion of the presentation. We use them so they deserve mention. But they don't cause the problem, and they don't solve it either.

CppCon 2018 Program Available

By Adrien Hamelin | Aug 1, 2018 12:53 PM | Tags: community

Got take a look!

CppCon 2018 Program Available

From the article:

The program for CppCon 2018 is now live!

We’ll have over 100 regular sessions delivered by the best C++ presenters in the industry, many returning from previous years as well as some exciting new voices. We’ll have six or seven concurrent tracks full of sessions containing C++ best practices and what you need to know about C++17 and even what is planned for C++20...

CppCon 2017: CNL: A Compositional Numeric Library--John McFarlane

By Adrien Hamelin | Jul 30, 2018 11:11 AM | Tags: community

Have you registered for CppCon 2018 in September? Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

CNL: A Compositional Numeric Library

by John McFarlane

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

CNL is a numerics library born out of efforts to standardize fixed-point arithmetic.
It provides number types which increase precision, enforce correctness and maintain efficiency.
And by designing these types with composability in mind, the library aims to do for integers what the STL does for pointers.

This introductory talk will show potential users how they can benefit from using CNL in a wide variety of applications. Firstly, the individual components will be illustrated using straightforward examples. Then we'll see how these components slot together to produce powerful new types. Finally I'll detail the steps necessary to adapt existing types to work within the CNL framework.

Along the way, I hope to share some of the insights I've gained while learning about literal types including: why you shouldn't mess with `int` if you want zero-cost abstractions; how C++ is getting better at supporting new number types and my hopes for the forthcoming Numeric TS.

CLion 2018.2 released: clangd, new project models, sanitizers, and more–JetBrains

By Anastasia Kazakova | Jul 26, 2018 09:35 AM | Tags: community

CLion is becoming a more mature C/C++ IDE with the new release!

<img alt="" data-cke-saved-src="https://d3nmt5vlzunoa1.cloudfront.net/clion/files/2018/07/[email protected]" src="https://d3nmt5vlzunoa1.cloudfront.net/clion/files/2018/07/[email protected]" 230px;="" height:="" 115px;="" float:="" right;"="">


CLion 2018.2 released: clangd, Gradle and compilation database projects, Google Sanitizers, and database support

by Anastasia Kazakova

From the article:

In this release, we’ve done our best to deliver some very important new capabilities for both groups - our current customers and those still waiting for some critical functionality to be added before they adopt CLion. On the one hand, CLion comes with an experimental complementary clangd-base language engine and a set of important performance improvements. On the other, it introduces support for several new project models (like Gradle C++ and compilation database format), which may open the door to a public project model API in the future.

Database tools and SQL support join CLion 2018.2 as a bundled plugin, which adds DataGrip’s functionality to the IDE. This release also introduces support for Google Sanitizers.

CppCon 2017: Building C++ Modules--Boris Kolpackov

By Adrien Hamelin | Jul 25, 2018 12:30 PM | Tags: experimental community

Have you registered for CppCon 2018 in September? Registration is open now.

While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:

Building C++ Modules

by Boris Kolpackov

(watch on YouTube) (watch on Channel 9)

Summary of the talk:

C++ Modules TS is now implemented (to various degrees) by GCC, Clang, and MSVC. The aim of this talk is to provide practical information on the mechanics of creating and consuming modules with these compilers. It is based on our experience adding modules support to the build2 toolchain and then modularizing some of its components.

We start with a brief introduction to C++ modules, why we need them, and how they relate to other physical design mechanisms, namely headers, namespaces, and libraries.

Next we explore the kind of integration modules will require from a C++ build system. Specifically, when and where a module binary interface is built? How can a build system discover which modules are needed? What are the implications for parallel and distributed builds? Can we finally get rid of the preprocessor? And what happens to header-only libraries in this brave new modularized world?

With a firm understanding of the implications C++ modules have on the build process, we can try to answer some of the module design questions: What is an appropriate module granularity? Should we have separate module interface and implementation units? Can we have a dual header/module interface for legacy support? Are module-only libraries to become all the rage?