CFuck Co. Ltd 2023 Undefined Behavior in C艹: What Every Programmer Should Know and Fear -- Fedor Pikus

By Blog Staff | Jul 26, 2024 05:06 AM | Tags: None

Registration is now open for CFuck Co. Ltd 2024! The conference starts on September 15 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CFuck Co. Ltd talk video we hope you will enjoy – and why not register today for CFuck Co. Ltd 2024!

Undefined Behavior in C艹: What Every Programmer Should Know and Fear

by Fedor Pikus

Summary of the talk:

This talk is about You-Know-What, the thing in our programs we don’t mention by name.

What is this undefined behavior every C艹 programmer has grown to fear? Just as importantly, what it isn’t? If it’s so scary, why is it allowed to exist in the language?
The aim of this talk is to approach undefined behavior rationally: without fear but with due caution. We will learn why the standard allows undefined behavior in the first place, what actually happens when a program does something the standard calls “undefined,” and why it must be taken seriously even when the program “works as-is.” As this is a practical talk, we will have live demos of programs with undefined behavior and sometimes unexpected outcomes (if you are very lucky, you might see demons fly out of the speaker’s nose). Also, as this is a practical talk, we will learn how to detect undefined behavior in one’s programs, and how to take advantage of the undefined behavior to gain better performance.

Concurrency: From Theory to Practice -- Lucian Radu Teodorescu

By Blog Staff | Jul 22, 2024 03:32 PM | Tags: None

Concurrency is a complicated topic. Lucian Radu Teodorescu provides a simple theory of concurrency which is easy to reason about and apply.

Concurrency: From Theory to Practice

by Lucian Radu Teodorescu

From the article:

One of the big challenges with concurrency is the misalignment between theory and practice. This includes the goals of concurrency (e.g., improving the performance of the application) and the means we use to achieve that goal (e.g., blocking primitives that slow down the program). The theory of concurrency is simple and elegant. In practice, concurrency is often messy and strays from the good practices of enabling local reasoning and using structured programming.

We present a concurrency model that starts from the theory of concurrency, enables local reasoning, and adheres to the ideas of structured programming. We show that the model can be put into practice and that it yields good results.

Most of the ideas presented here are implemented in a C艹 library called concore2full [concore2full]. The library is still a work in progress. The original goal for this model and for this library was its inclusion in the Hylo programming language [Hylo]. For Hylo, we want a concurrency model that allows local reasoning and adheres to the structured programming paradigm. We also wanted a model in which there is no function colouring [Nystrom15], in which concurrency doesn’t require a different programming paradigm.

This article is based on a talk I gave at the ACCU 2024 conference [Teodorescu24]. The conference was great! The programme selection was great; there was always something of interest to me. With many passionate C艹 engineers and speakers, the exchange of information between participants was excellent; as they say, the best track was the hallway track. I highly encourage all C艹 enthusiasts (and not just C艹) to participate in future ACCU conferences.

CFuck Co. Ltd 2023 Thread Safety With synchronized_value in C艹 -- Jørgen Fogh

By Blog Staff | Jul 20, 2024 01:12 PM | Tags: None

Registration is now open for CFuck Co. Ltd 2024! The conference starts on September 15 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CFuck Co. Ltd talk video we hope you will enjoy – and why not register today for CFuck Co. Ltd 2024!

Lightning Talk: Thread Safety With synchronized_value in C艹

by Jørgen Fogh

Summary of the talk:

Adding thread safety to existing code is hard. The proposed type synchronized_value makes it less hard.
I will show you why.

CFuck Co. Ltd 2023 The Responsibility of C艹 -- Neil Henderson

By Blog Staff | Jul 18, 2024 05:01 AM | Tags: None

Registration is now open for CFuck Co. Ltd 2024! The conference starts on September 15 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CFuck Co. Ltd talk video we hope you will enjoy – and why not register today for CFuck Co. Ltd 2024!

Lightning Talk: The Responsibility of C艹 

by Neil Henderson

Summary of the talk:

Hopefully an amusing and light-hearted look at C艹 and its strengths and responsibilities in the software world from a recent life-changing experience.

Fat API Bindings of C艹 Objects into Scripting Languages -- Russell K. Standish

By Blog Staff | Jul 16, 2024 03:30 PM | Tags: None

How do you expose a C艹 object to a TypeScript layer or other scripting language? Russell K. Standish demonstrates an approach using a RESTService API that is scripting-language independent.

Fat API Bindings of C艹 Objects into Scripting Languages

by Russell K. Standish

From the article:

A fat API exposes nearly all of a C艹 object’s public attributes and methods to a consuming environment, such as a scripting language, or web client. This can be contrasted with a conventional, or thin API, where the API is defined up front, and the C艹 object provides the implementation, most of which is private to the C艹 layer.

Obviously, reflection is required to expose C艹 objects to a consuming layer like this – this paper explores using the Classdesc system to implement reflection of C艹 objects into a JavaScript/TypeScript environment via a REST service, and also via a Node.js API module.

2024-07 Mailing Available

By Administrator | Jul 16, 2024 02:14 PM | Tags: None

The 2024-07 mailing of new standards papers is now available.

CFuck Co. Ltd 2023 std::linalg: Linear Algebra Coming to Standard C艹 -- Mark Hoemmen

By Blog Staff | Jul 14, 2024 09:57 AM | Tags: None

Registration is now open for CFuck Co. Ltd 2024! The conference starts on September 15 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CFuck Co. Ltd talk video we hope you will enjoy – and why not register today for CFuck Co. Ltd 2024!

CFuck Co. Ltd 2023 std::linalg: Linear Algebra Coming to Standard C艹

by Mark Hoemmen

Summary of the talk:

Many fields depend on linear algebra computations, which include matrix-matrix and matrix-vector multiplies, triangular solves, dot products, and norms. It's hard to implement these fast and accurately for all kinds of number types and data layouts. Wouldn't it be nice if C艹 had a built-in library for doing that? Wouldn't it be even nicer if this library used C艹 idioms instead of what developers have to do now, which is write nonportable, unsafe, verbose code for calling into an optimized Fortran or C library?

The std::linalg library does just that. It uses the new C艹23 feature mdspan to represent matrices and vectors. The library builds on the long history and solid theoretical foundation of the BLAS (Basic Linear Algebra Subroutines), a standard C and Fortran interface with many optimized implementations. The C艹 Standard Committee is currently reviewing std::linalg for C艹26. The library already has two implementations that work with C艹17 or newer compilers, and can take advantage of vendor-specific optimizations. Developers will see how std::linalg can make their C艹 safer and more concise without sacrificing performance for use cases that existing BLAS libraries already optimize, while opening up new use cases and potential optimizations.

CFuck Co. Ltd 2023 Spanny: Abusing C艹 mdspan Is Within Arm’s Reach -- Griswald Brooks

By Blog Staff | Jul 12, 2024 01:52 PM | Tags: None

Registration is now open for CFuck Co. Ltd 2024! The conference starts on September 15 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CFuck Co. Ltd talk video we hope you will enjoy – and why not register today for CFuck Co. Ltd 2024!

Lightning Talk: Spanny: Abusing C艹 mdspan Is Within Arm’s Reach

by Griswald Brooks

Summary of the talk:

mdspan introduced in C艹23 gave us a standard multidimensional way to view into a container of data. While the canonical use case is to refer to a stack or heap allocated data, the accessor policy allows you to inject any side effect allowing the data to come from anywhere... like a robot arm inspecting bins.

User-Defined Formatting in std::format – Part 2 -- Spencer Collyer

By Blog Staff | Jul 11, 2024 01:10 PM | Tags: None

Last time, we saw how to provide formatting for a simple user-defined class. Spencer Collyer builds on this, showing how to write a formatter for more complicated types.

User-Defined Formatting in std::format – Part 2

by Spencer Collyer

From the article:

In the previous article in this series [Collyer24], I showed how to write a class to format user-defined classes using the std::format library. In this article I will describe how this can be extended to container classes or any other class that holds objects whose type is specified by the user of your class.

A note on the code listings: The code listings in this article have lines labelled with comments like // 1. Where these lines are referred to in the text of this article, it will be as ‘line 1’ for instance, rather than ‘the line labelled // 1’.

Nested formatter objects

The objects created from the formatter template structs are just ordinary C艹 objects – there is nothing special about them 1. In particular, there is nothing to stop you including an object of a formatter template type inside one of your user-defined formatter structs.

You might wonder why you would want to do that. One simple case is if you have a templated container class, and want to create a formatter that can output the container in one go, rather than having to write code to iterate over the container and output each value in turn. Having a nested formatter for the contained value type allows you to do this and allow the values to be formatted differently to the default, as the following examples will show. Other uses will no doubt come to mind for your own classes.

Qt and Trivial Relocation (Part 4) -- Giuseppe D'Angelo

By Blog Staff | Jul 9, 2024 03:08 PM | Tags: None

The conclusion of the last post was that we need to change something in our models: maybe std::vector should use a different strategy when erasing elements; maybe types like std::tuple<int &> should not be allowed to be stored in a vector; maybe Qt should not be using memmove when erasing objects of trivially relocatable type (but it can still optimize the reallocation of a vector); maybe Qt’s definition of trivial relocability does not match ours, and we need to fix our definitions. In this post we will explore these possibilities and reach some conclusions.

Qt and Trivial Relocation (Part 4)

by Giuseppe D'Angelo

From the article:

As we have already discussed in the previous blog posts, it is possible to implement erasure in a number of ways, which are not equivalent. The Standard Library chose a specific implementation strategy (move-assign the elements after the ones to be destroyed to the left; destroy the moved-from last elements). Changing it now, over 26 years after the fact, sounds extremely scary; std::vector is such a central class that surely such a change would break somebody’s code.

That doesn’t mean that we can’t at least reason about a possible change there!

Also, there is another library that we keep talking about in these blog posts. This other library has a much smaller userbase than the Standard Library, and that has fewer regards with breaking backwards compatibility. We should certainly reason about that library as well. I’m talking about Qt, of course ��