Moving from C to Modern C++

Thu, 28 Nov 2024 18:49:38 +0000

Two talks at Meeting C++ have dealt with moving from C to C++:

From C to Modern C++: Transforming the classroom and beyond - Gabriel Valenzuela - Meeting C++ 2024

C++ for C Developers - Migration from C to C++ - Slobodan Dmitrovic - Meeting C++ 2024

]]>

CopperSpice: std::launder

Mon, 25 Nov 2024 18:27:26 +0000

New video on the CopperSpice YouTube Channel:

std::launder

by Barbara Geller and Ansel Sermersheim

About the video:

Our recent C++ video started a lively conversation. We showed a use case for std::launder which caught several developers off guard. A new compiler setting was enabled which exposed a problem in our existing code. Please watch the full video to find out what we learned.

Take a look and remember to subscribe.

]]>

First Video: C++26: an overview - Rainer Grimm - Meeting C++ 2024

Wed, 20 Nov 2024 12:10:10 +0000

The first video from Meeting C++ 2024 has been released:

C++26: an overview - Rainer Grimm @ Meeting C++ 2024

by Rainer Grimm

Watch the video:

]]>

Interview with Titus Winters for Meeting C++ 2024

Sat, 26 Oct 2024 12:53:42 +0000

This week Titus Winters gave an interview for Meeting C++ 2024 about his thoughts on his new role at Adobe and the wider role of C++ in Softwareengineering and its current challenges.

Interview with Titus Winters for Meeting C++ 2024

by Jens Weller & Titus Winters

Watch the video:

]]>

AMA with Herb Sutter - Meeting C++ live

Sat, 12 Oct 2024 12:57:37 +0000

Meeting C++ hosted an online AMA with Herb Sutter on Friday.

AMA with Herb Sutter - Meeting C++ live

by Jens Weller & Herb Sutter

Video:

]]>

IoT Development with POCO C++ libraries and macchinaio

Sat, 28 Sep 2024 13:45:35 +0000

Recently Günter Obiltschnig from the POCO Project gave a talk about IoT Development with POCO C++ libraries and macchinaio at a by macchina.io sponsored Meetup of Meeting C++ online.

IoT Development with POCO C++ libraries and macchinaio

by Günter Obiltschnig

Chapter Videos:

POCO C++ Libraries overview

Macchina.io overview

Projects using POCO C++ Libaries and macchina.io in the real world

Q&A with Günter Obiltschnig after the talk

]]>

CopperSpice: Template Design With Policy Classes

Tue, 24 Sep 2024 20:21:08 +0000

New video on the CopperSpice YouTube Channel:

Template Design With Policy Classes

by Barbara Geller and Ansel Sermersheim

About the video:

We have a new C++ video which discusses Policy Based Design and compares it to other styles of programming. Do you know which design pattern policy based programming solves? Have you considered the benefits of a design which provides a solution at compile time versus run time? Are you using policies and maybe you had no idea they had a name?

Please take a look and remember to subscribe.

]]>

CppCon 2023 Undefined Behavior in C++: What Every Programmer Should Know and Fear -- Fedor Pikus

Fri, 26 Jul 2024 12:07:04 +0000

Registration is now open for CppCon 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 CppCon talk video we hope you will enjoy – and why not register today for CppCon 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.

]]>

CppCon 2023 Thread Safety With synchronized_value in C++ -- Jørgen Fogh

Sat, 20 Jul 2024 20:13:45 +0000

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.

]]>

CppCon 2023 The Responsibility of C++ -- Neil Henderson

Thu, 18 Jul 2024 12:02:02 +0000

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.

]]>

CppCon 2023 std::linalg: Linear Algebra Coming to Standard C++ -- Mark Hoemmen

Sun, 14 Jul 2024 16:58:40 +0000

CppCon 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.

]]>

CppCon 2023 Spanny: Abusing C++ mdspan Is Within Arm’s Reach -- Griswald Brooks

Fri, 12 Jul 2024 20:53:14 +0000

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.

]]>

CppCon 2023 Robots Are After Your Job: Exploring Generative AI for C++ -- Andrei Alexandrescu

Mon, 08 Jul 2024 18:28:11 +0000

Robots Are After Your Job: Exploring Generative AI for C++

by Andrei Alexandrescu

Summary of the talk:

Almost a year since the launch of ChatGPT – considered by many as the first truly compelling code generator that translates free-form human language into code – the C++ community continues to grapple with the implications. Reactions range from indifference or skepticism to genuine concern about the future of human programmers.

Although some advanced C++ techniques are already accessible to tools like ChatGPT, certain fundamental aspects remain outside the reach of current and possibly next-generation generative AI tools. This disparity raises pivotal questions: Which parts of the intricate C++ ecosystem can we confidently delegate to generative AI? What uniquely human skills must we retain and refine?

We'll probe the potential and limits of contemporary AI, taking a novel look at the age-old binary search algorithm. Although this algorithm has long been held up as a paragon of efficiency, we challenge that notion. What would ChatGPT have to say about it, and how might it partner with us to refine this cornerstone of algorithmic logic? The conversation opens a window into a future where developers become the "one percenters" of programming—focusing solely on the most cerebral and high-level challenges, while AI takes care of the everyday tasks. Join us to explore this fascinating paradigm shift and reflect on what it means for your own work in and with C++.

]]>

CppCon 2023 Coping With Other People's C++ Code -- Laura Savino

Sat, 06 Jul 2024 18:26:00 +0000

Plenary: Coping With Other People's C++ Code

by Laura Savino

Summary of the talk:

Sometimes we're fortunate enough to work with a small group of devs who share our coding values, and when we see their PRs come in, we nod along and say, "Yup, that's what I would have done. Oh, nice, that one's even better than my usual approach, I'd better tuck that idea away for next time."

This perfect alignment is precious... and particularly elusive in C++. Most of us are living in codebases that are profitable, complex, and updated in ways with which we have legitimate beef. How can we keep a sense of curiosity, progress, and satisfaction amidst patterns we would never have chosen?

This presentation explores the often-overlooked social aspects of C++ development, offering both practical tools and light-hearted commiseration. We'll draw from the field of behavior science to build strategies that address conflicting design patterns and the strong opinions that come with them.

]]>

CppCon 2023 Writing a Better std::move -- Jonathan Müller

Mon, 01 Jul 2024 18:23:58 +0000

Lightning Talk: Writing a Better std::move

by Jonathan Müller

Summary of the talk:

std::move allows the creation of const rvalue references, which is almost always wrong. It also allows moving out of lvalue references, which can be dangerous since you don't have real ownership over them and a caller might not expect the object to disappear. Let's fix those problems using macros, reflection, and more macros.

]]>

CppCon 2023 Linkers, Loaders and Shared Libraries in Windows, Linux, and C++ -- Ofek Shilon

Fri, 28 Jun 2024 18:20:53 +0000

Linkers, Loaders and Shared Libraries in Windows, Linux, and C++

by Ofek Shilon

Summary of the talk:

This talk would give a crash-intro to linkers, loaders and the layout of program binaries, and explore just enough internals to understand some observable differences in C++ builds between Linux and Windows.

We will discuss the GOT, the PLT, symbol visibility, interposition, lazy binding and more. There will be a lot of details, but also a lot of 'why's and opinions.

We will also touch/rant on what the C++ standard has to say on adjacent matters. There's a good chance you've heard before "shared libraries are outside the scope of the standard", but it doesn't mean what you think it does.

]]>

CppCon 2023 Libraries: A First Step Toward Standard C++ Dependency Mgmt--Bret Brown & Bill Hoffman

Thu, 27 Jun 2024 18:15:49 +0000

Plenary: Libraries - A First Step Toward Standard C++ Dependency Management

by Bret Brown & Bill Hoffman

Summary of the talk:

Prebuilt libraries have existed for decades… they even predate C++! After all these years, techniques to use prebuilt libraries are still ad hoc and difficult to maintain. A root cause of this variety of techniques is the variety of things that are C++ libraries: header-only libraries, statically-linked archives, dynamically-linked binaries, and so on. The consuming projects need to build against these libraries in consistent ways or risk unproductive workflows – and potentially, even catastrophic failure in production environments. This lack of convergence creates enormous interoperability problems across broad portions of the worldwide programming ecosystem, not just the C++ parts of it.

This talk will explore the complexities of defining what is a “C++ library.” It will then present the joint work of Kitware, Bloomberg, and others toward a preliminary design for creating initial standards for dependency management in C++ – metadata files to describe prebuilt libraries. A roadmap for maturing the design will also be shared, including proposing a standard definition for C++ libraries, building on previous proposals such as P1313: Package Specification (https://wg21.link/P1313).

This talk is intended for anyone who produces, maintains, or consumes C++ libraries. Special knowledge of C++ tooling, build systems, or package managers is not required.

]]>

Sean Baxter: Safe C++

Thu, 27 Jun 2024 14:34:03 +0000

Sean Baxter demonstrates memory safe C++ using his Circle compiler

Safe C++
Sean Baxter

From the talk:

Does a subset of a superset of C++ exists that achieves similar safety guarantees to rust, is useful and expressive enough, and is compatible with today's C++? If so, is anyone mad enough to do it? There is an answer to that

]]>

CppCon 2023 Let's Fix Sparse Linear Algebra with C++. It'll Be Fun and Easy! -- Benjamin Brock

Mon, 24 Jun 2024 18:12:23 +0000

Lightning Talk: Let's Fix Sparse Linear Algebra with C++. It'll Be Fun and Easy!

by Benjamin Brock

Summary of the talk:

Sparse linear algebra is hard. There are a large variety of different sparse linear algebra formats, and they all require obtuse index arithmetic in order to use. But what if we could fix this? In this talk, I'll present an idea for "fixing sparse linear algebra" using customization points, the ranges library, and high-level multi-dimensional iteration.

]]>

CppCon 2023 Implementing Coroutines Using C++17 -- Alon Wolf

Sat, 22 Jun 2024 18:09:22 +0000

Lightning Talk: Implementing Coroutines Using C++17

by Alon Wolf

Summary of the talk:

In this lightning talk, we will explore the journey of implementing coroutines in C++17 before they were added to the language in C++20.

The implementation uses macros, template metaprogramming, assembly functions, and more that resulting in working coroutines despite somewhat "horrible" code.

Discover how local variables within the coroutine body were leveraged to calculate frame sizes and ensure correct variable lifetimes during suspension, resumption, and destruction.

]]>

CppCon 2023 C++ Memory Model: from C++11 to C++23 -- Alex Dathskovsky

Thu, 20 Jun 2024 18:05:09 +0000

C++ Memory Model: from C++11 to C++23

by Alex Dathskovsky

Summary of the talk:

In the realm of C++ development, threading and memory management play a crucial role in crafting highly parallel and optimized programs. However, the absence of a memory model in C++98 posed challenges. Thankfully, with the advent of C++11, significant changes were introduced, including the introduction of a memory model, which brought forth a plethora of new and exciting tools for developers to leverage. This talk aims to delve into the realm of the C++ memory model, showcasing the arsenal of tools at our disposal. Attendees will gain insights into how CPUs and compilers optimize code and understand the criticality of adhering to the memory model correctly. Practical guidelines on utilizing these tools effectively will also be explored.

Throughout the talk, we will illustrate practical examples and share best practices for utilizing the diverse set of tools now available to us. From atomic operations to memory barriers, we will explore the range of techniques that allow us to develop robust and thread-safe code.

This talk will also illustrate the newer tools from newer C++ standards like JThread and so this talk will show how memory model is used and how it advanced since C++11.

]]>

CppCon 2023 Help! My Expression Template Type Names Are Too Long! -- Braden Ganetsky

Tue, 18 Jun 2024 18:02:38 +0000

Lightning Talk: Help! My Expression Template Type Names Are Too Long!

by Braden Ganetsky

Summary of the talk:

Even the name of this talk is too long! If we're ever working with expression templates, we can easily make type names long enough to slow down compilation time. Suddenly our "zero-overhead" expression templates start giving a large compile time overhead. I'll show off a C++20 trick to fix this problem.

]]>

CppCon 2023 Filling the Bucket: Reading Code, C++ Code Interviews & Exams -- Amir Kirsh

Sun, 16 Jun 2024 17:58:40 +0000

Lightning Talk: Filling the Bucket: Reading Code, C++ Code Interviews & Exams

by Amir Kirsh

Summary of the talk:

We are going to review and practice a reading code challenge. Reading code skills are quite important, maybe even more than writing code. So let's dive together into filling the bucket code reading challenge!

]]>

CppCon 2023 Back to Basics: The Rule of Five in C++ -- Andre Kostur

Thu, 13 Jun 2024 18:32:51 +0000

Back to Basics: The Rule of Five in C++

by Andre Kostur

Summary of the talk:

Designing a class to behave correctly when copied and moved takes a lot of thought. The Core Guidelines provide guidance to streamline that work. In this talk we are going to look at the Core Guideline known as "the Rule of Five", how it came about, and is there anything better.

]]>

C++ Safety with Herb Sutter

Wed, 12 Jun 2024 06:53:22 +0000

The U.S. government released a report calling on the technical community to proactively reduce the attack surface area of software infrastructure. Herb tackles the concerns cast on C++ on memory safety.

C++ Safety with Herb Sutter

by Jordi Mon Companys in Software Engineering Daily

From the interview:

It's really, really important as native languages C and C++, not to have our heads in the sand and say, "Oh, well, we've been hearing this for years. All is well." No, it's not. We have work to do. But it's also important not to go to the other extreme, and think that, "Oh, if we just magically wave a wand and make all the world's software, suddenly convert overnight to memory-safe languages", which would be great if it can be done. It's not technically feasible. ut even if we could do that, we're not going to make most of the attacks go away.

]]>

CppCon 2023 Exceptionally Bad: The Misuse of Exceptions in C++ & How to Do Better -- Peter Muldoon

Tue, 11 Jun 2024 18:33:31 +0000

Exceptionally Bad: The Misuse of Exceptions in C++ & How to Do Better

by Peter Muldoon

Summary of the talk:

Exceptions were originally heralded as a new modern way to handle errors. However the C++ community is split as to whether exceptions are useful or should be banned outright. It has not helped the pro-exception lobby that in their enthusiasm to embrace exceptions, a lot of code has been written that puts exceptions in a bad light.

In this talk, We will present the original intent/history of exceptions and a brief overview of how exception mechanics work and how they circumvent the usual stack return mechanism to set the stage. we will then examine the philosophy of using exceptions and then the many cases of exception misuse including resource management, retries, hierarchies, data passing and control flow to name but a few.

For each case, we will then suggest better ways to handle each specific situation. In many cases, exceptions are often dropped in favor of some other more appropriate paradigm.
Finally, we will introduce situations that can truly benefit from exceptions and what a model exception class might look like.

]]>

CppCon 2023 You Should Use Address Sanitizer -- Brody Holden

Sat, 08 Jun 2024 17:43:08 +0000

Lightning Talk: You Should Use AddressSanitizer

by Brody Holden

Summary of the talk:

This talk aims to get you, yes you, to use Address Sanitizer. ASan will detect various memory errors and is worth your time.

]]>

CppCon 2023 Delivering Safe C++ -- Bjarne Stroustrup

Thu, 06 Jun 2024 17:35:42 +0000

Delivering Safe C++

by Bjarne Stroustrup

Summary of the talk:

Type safety was one of the key initial C++ design ideals. We have evolved C++ to the point where we can write C++ with no violations of the type system, no resource leaks, no memory corruption, no garbage collector, no limitation of expressiveness or performance degradation compared to well-written modern C++.

We face three major challenges: To define what “safe” means in the context of various C++ uses, to guarantee such safety where guarantees are needed, and to get developers to write such verified safe code.

I outline an approach based on safety profiles to address these challenges, describe an approach to eliminate dangling pointers, and suggest how to eliminate all dangling pointers and all range errors. My aim for key applications is verified type-and-resource-safe C++. An emphasis is on minimizing costly run-time checks through the use of abstractions. I see the current emphasis on safety as an opportunity to complete one aspect of C++’s fundamental aims in real-world code.

]]>

CppCon 2023 Cooperative C++ Evolution - Toward a Typescript for C++ -- Herb Sutter

Mon, 03 Jun 2024 21:04:52 +0000

Plenary: Cooperative C++ Evolution - Toward a Typescript for C++

by Herb Sutter

Summary of the talk:

C++23 is done. But C++ is not! In this talk I’ll give my personal perspectives on:

C++’s ongoing and very active evolution;

The latest progress updates on my cppfront experimental compiler, and what I’ve learned about modern ISO C++20 and C++23 in the experiment (https://github.com/hsutter/cppfront);

Why compatibility (and what kind, and how much) is essential; and

Why we should aim to keep bringing C++ forward successfully by cooperating and being part of C++’s ongoing true evolution via WG 21, even though that’s more work than pursuing a new fresh-but-competing evolutionary path.

]]>

CppCon 2023 ClangFormat Is Not It -- Anastasia Kazakova

Sat, 01 Jun 2024 21:01:09 +0000

Lightning Talk: ClangFormat Is Not It

by Anastasia Kazakova

Summary of the talk:

Sometimes things are not what we think of them. But we keep using them based on our perception. ClangFormat is a widely used tool by the C++ community. Join me to explore the typical delusions around it.

]]>

CppCon 2023 C++ Modules: Getting Started Today -- Andreas Weis

Mon, 27 May 2024 20:57:03 +0000

C++ Modules: Getting Started Today

by Andreas Weis

Summary of the talk:

Modules have been one of the most highly anticipated features of C++20. Unfortunately, it was also the language feature that took the longest to become widely available for developers to use. This year, for the first time, we see broad support for the feature in all major compilers and mainstream build system support through CMake. The goal of this talk is to provide you with all the basic knowledge to allow you getting started with C++20 modules today.

We will take a look at how modules change the build process and why it took so long to implement them. We will take a tour of the essentials of the named modules mechanism and explore the new best practices for physical code structure in a modules-based code base, including how to set up a build with CMake. And last but not least, we will discuss different options for interacting with existing header-based code.

The talk will focus above all else on practicality: We will only be covering features that are widely available for use today with the latest compilers and build tools. We will give special attention to the areas where the design practices for modules differ from the familiar header-based approach and address common misconceptions and pitfalls that are typical among developers first encountering the feature. No prior knowledge of modules is required.

]]>

CppCon 2023 Higher-Order Template Metaprogramming with C++23 -- Ed Catmur

Sun, 26 May 2024 20:52:49 +0000

Lightning Talk: Higher-Order Template Metaprogramming with C++23

by Ed Catmur

Summary of the talk:

C++20's Concepts transformed metaprogramming, but they can still be inflexible and are not readily composable. I demonstrate a few simple yet powerful techniques to allow building concepts from type traits, type transformations and even other concepts.

]]>

CppCon 2023 File I/O for Game Developers: Past, Present, and Future with C++ -- Guy Davidson

Fri, 24 May 2024 20:46:43 +0000

File I/O for Game Developers: Past, Present, and Future with C++

by Guy Davidson

Summary of the talk:

If you have played a game on a computer in the last few decades, you will most likely have encountered a loading screen. This is used to advertise to the player that, among other things, data is being loaded from a storage device into the game. But why does this exist, why does it take so long, and how can we improve matters for the player?

In this talk we will discover the history of games and their development environments, the relationship between address space, RAM and storage hardware, how C++ abstracts file I/O and why it might not be the best fit for game developers, how a 64-bit address space changes everything, how #embed will change everything, and how C++29 (yes, 29) may upset the applecart yet again.

Although this talk is aimed at game developers who are often Windows programmers, it is relevant to anyone who has to read large amounts of data from local storage. Expect tales of woe, discovery and jubilation as I describe every surprising little thing I've learned about file I/O over the past 40 years and how C++ is heading for a great future in games.

]]>

CppCon 2023 Back to Basics: Iterators in C++ -- Nicolai Josuttis

Wed, 22 May 2024 20:42:48 +0000

Back to Basics: Iterators in C++

by Nicolai Josuttis

Summary of the talk:

One key success factor of C++ was the introduction of the Standard Template Library (STL) bringing together containers/ranges and algorithms using iterators as glue API to iterate over elements of collections.

This talk will present the basics of the design of iterators, the various consequences, remarkable corner cases, and what this means when using ranges and views as introduced with C++20.

]]>

CppCon 2023 Whitespace: A Humorous Short Talk -- Dan Curran

Sun, 19 May 2024 20:39:29 +0000

Lightning Talk: Whitespace: A Humorous Short Talk

by Dan Curran

Summary of the talk:

i want a holy war over whitespace. the most productive discussion.

]]>

CppCon 2023 C++23: An Overview of Almost All New and Updated Features -- Marc Gregoire

Fri, 17 May 2024 20:23:32 +0000

C++23: An Overview of Almost All New and Updated Features

by Marc Gregoire

Summary of the talk:

As I have done for previous C++ Standard versions, I will explore almost all new and updated C++ features that come with the C++23 standard. C++23 is not as big of an update as C++20 was, but it does contain numerous new and updated features to both the core language and the Standard Library. The goal of this session is not to discuss all new and changed features in detail, as that is not possible in a one-hour session. Instead, at the end of the session, you should have a high-level overview of everything that's new or changed in C++23, and it might even change how you are using existing features.

The session will touch on the following core language and Standard Library topics.

C++23 core language changes include explicit object parameters (deducing this), if consteval, multidimensional subscript operators, built-in decay copy support, ability to mark unreachable code, support for specifying platform-independent assumptions, named universal character escapes, and more.

C++23 Standard Library changes include string formatting improvements, formatting of entire ranges, standard named modules std and std.compat, new containers flat_map and flat_set, multidimensional span aka mdspan, a standard generator coroutine, monadic operations on optionals, working with stacktraces at run time, many changes to the ranges library, std::expected as an alternative to exceptions, and more.

Throughout the session, the slides will contain references to other CppCon sessions with more details on specific topics.

]]>

CppCon 2023 A Journey Into Non-Virtual Polymorphism in C++ -- Rudyard Merriam

Mon, 13 May 2024 20:18:59 +0000

CppCon 2023 A Journey Into Non-Virtual Polymorphism in C++

by Rudyard Merriam

Summary of the talk:

Join me on an introductory journey into polymorphism that doesn't use class inheritance and virtual functions. I'll share my amazement at how polymorphism permeates C++. Then we'll visit the long-used Curiously Recurring Template Pattern (CRTP) with its modernization using implicit this.

Do you like lambdas? So does the override pattern, which uses them to handle std::tuples and std::variants with std::apply and std::visit.

Want to walk through a container of disparate types invoking their functions? You'll see this and all the above in code examples galore.

Afterward, you'll be eager to learn more on your own!

]]>

Pure Virtual C++ 2024 Recordings Available

Mon, 13 May 2024 15:10:19 +0000

The recordings for all Pure Virtual C++ 2024 sessions are now online. This includes the 5 main sessions plus over a dozen pre-conference videos.

Pure Virtual C++ 2024 Recordings Available

By Sy Brand

From the article:

All recordings for our Pure Virtual C++ 2024 conference are now available. Thanks to everyone who came along and hope to see you again next year! You can find the full playlist on YouTube.

]]>

CppCon 2023 A Fast, Concurrent Data Loader for Time-Series Data -- Glenn Philen

Fri, 10 May 2024 20:16:19 +0000

Lightning Talk: A Fast, Concurrent Data Loader for Time-Series Data

by Glenn Philen

Summary of the talk:

In this talk, I briefly share the design of a high performance data loader used to iterating over time series data stored on disk across many individual files. The data loader aggregates data streams from different sources and of different kinds of data, orders it by timestamp, and feeds it to an offline test harness concurrently and without locking.

]]>

CppCon 2023 Interfaces in C++ -- Megh Parikh

Wed, 08 May 2024 17:08:04 +0000

Lightning Talk: Interfaces in C++ - Megh Parikh - CppCon 2023

by Megh Parikh

Summary of the talk:

I explain some of the ways to make interfaces, both static and dynamic in this talk, and how concepts can be optionally used.

]]>

CopperSpice: Declarations Gone Wrong -- Copperspice

Fri, 26 Apr 2024 19:40:01 +0000

New video on the CopperSpice YouTube Channel:

Declarations Gone Wrong

by Barbara Geller and Ansel Sermersheim

About the video:

A new C++ video has been uploaded to our YouTube channel about how declarations work and what happens when they go wrong.

Do you know which part of a declaration is the declarator? How about what can happen with multiple variables in one declaration statement? Let us entertain you with the surprising details, including some most programmers have never seen or considered.

Please take a look and remember to subscribe.

]]>

Why you shouldn't have virtual member functions with default parameters -- Andreas Fertig

Fri, 26 Apr 2024 19:33:55 +0000

In this episode, you learn how default parameters work and why you shouldn't put them on virtual member functions.

C++ Insights Episode 49: Why you shouldn't have virtual member functions with default parameters

by Andreas Fertig

]]>

Machine Code Explained -- Matt Godbolt

Fri, 09 Feb 2024 00:35:22 +0000

Explaining machine code from the ground up!

Machine Code Explained

by Matt Godbolt

From the video:

In this video, Matt Godbolt appears on Computerphile to discuss their fascination with how computers work and their mental model developed in the 1980s, which still helps them understand modern computer systems. They use a simple analogy involving a robot with an abacus and pigeonholes to explain fundamental computer operations and how programs are executed. Matt then demonstrates how machine code, the computer's language, can be represented as a sequence of numbers and stored in memory to instruct the computer in performing tasks, illustrating the basic concept of programming.

]]>

CopperSpice: Generic vs Meta Programming

Thu, 25 Jan 2024 17:55:46 +0000

New video on the CopperSpice YouTube Channel:

Generic vs Meta Programming

by Barbara Geller and Ansel Sermersheim

About the video:

We released a new video which compares Generic and Meta Programming and how they are used in various computer languages like C++, Rust, and Go. In this video we also explain the definition of Template Meta Programming and when TMP is actually Reflection.

Simply using a template does not imply you are doing template meta programming and using a code generator does not mean you have implemented reflection.

Please take a look and remember to subscribe.

]]>

Releasing the keynotes of Meeting C++ 2023

Sat, 30 Dec 2023 10:39:32 +0000

Highlighting the current video releases for Meeting C++ 2023: the keynotes

With this year Meeting C++ had a unique set of keynotes, covering 6 impossible problems for software devs with the opening keynote by Kevlin Henney, followed by great wisdom about how open communities thrive by Lydia Pintscher. The closing keynote by Ivan Čukić was an impressive medley composing various idioms with Prog(ressive) C++.

All these keynotes are worth watching, a great contribution to our knowledge base as a community. Thanks to Kevlin Henney, Lydia Pintscher and Ivan Čukić for preparing these great presentations!

]]>

Prog C++ - Ivan Čukić - Closing Keynote Meeting C++ 2023

Fri, 22 Dec 2023 19:18:40 +0000

Ivan Čukić gave a great Closing Keynote at this years Meeting C++ conference in Berlin.

Prog C++ - Ivan Čukić - Closing Keynote Meeting C++ 2023

by Ivan Čukić

Video

]]>

Helping open communities thrive - Lydia Pintscher - Center Keynote Meeting C++ 2023

Wed, 20 Dec 2023 19:48:29 +0000

Lydia Pintscher of KDE and Wikimedia gave a great community focused keynote at Meeting C++ 2023

Helping open communities thrive - Lydia Pintscher - Center Keynote Meeting C++ 2023

by Lydia Pintscher

]]>

6 impossible things - Kevlin Henney - Opening Keynote Meeting C++ 2023

Sun, 17 Dec 2023 21:25:11 +0000

Kevlin Henney gave the opening keynote at Meeting C++ 2023

6 impossible things - Kevlin Henney - Opening Keynote Meeting C++ 2023

by Kevlin Henney

Video:

]]>

Promise-Cpp with Boost.Beast -- Richard Thomson

Wed, 08 Nov 2023 18:41:57 +0000

Utah C++ Programmers has released a new video:

Promise-Cpp with Boost.Beast

by Richard Thomson

From the video description:

Over the past few months, we've looked at asynchronous I/O and network programming using Boost.Asio and Boost.Beast. Those libraries connect to your application through the use of callbacks. When orchestrating a sequence of asynchronous operations, it is up to the application to ensure that the callbacks are invoked in the proper sequence.

This "callback hell" problem has long been recognized in the JavaScript world, as all I/O operations in JavaScript (timers or XML HTTP Requests) are asynchronous. In the JavaScript world this lead to promise oriented APIs that allowed for a more linear notation in expressing a sequence of asynchronous operations. This led to the Promises/A+ specification for JavaScript promises.

Promise-cpp is an implementation of the Promises/A+ specification for C++. It can integrate with Boost.Asio and Boost.Beast for asynchronous network programming support for low-level I/O as well as HTTP and WebSocket APIs.

https://www.youtube.com/watch?v=YnTaumB5HVM

]]>

CopperSpice: Time to Sort Out std::chrono

Sat, 28 Oct 2023 18:31:46 +0000

New video on the CopperSpice YouTube Channel:

Time to Sort Out std::chrono

by Barbara Geller and Ansel Sermersheim

About the video:

We just posted a new video about std::chrono. It provides an overview of the functionality which was added in C++11, C++17, and C++20. Please watch to find out how much of std::chrono your compiler actually supports. We were pretty surprised at what we discovered.

Please take a look and remember to subscribe.

]]>

Moving from C to Modern C++

CopperSpice: std::launder

First Video: C++26: an overview - Rainer Grimm - Meeting C++ 2024

Interview with Titus Winters for Meeting C++ 2024

AMA with Herb Sutter - Meeting C++ live

IoT Development with POCO C++ libraries and macchinaio

CopperSpice: Template Design With Policy Classes

CppCon 2023 Undefined Behavior in C++: What Every Programmer Should Know and Fear -- Fedor Pikus

CppCon 2023 Thread Safety With synchronized_value in C++ -- Jørgen Fogh

CppCon 2023 The Responsibility of C++ -- Neil Henderson

CppCon 2023 std::linalg: Linear Algebra Coming to Standard C++ -- Mark Hoemmen

CppCon 2023 Spanny: Abusing C++ mdspan Is Within Arm’s Reach -- Griswald Brooks

CppCon 2023 Robots Are After Your Job: Exploring Generative AI for C++ -- Andrei Alexandrescu

CppCon 2023 Coping With Other People's C++ Code -- Laura Savino

CppCon 2023 Writing a Better std::move -- Jonathan Müller

CppCon 2023 Linkers, Loaders and Shared Libraries in Windows, Linux, and C++ -- Ofek Shilon

CppCon 2023 Libraries: A First Step Toward Standard C++ Dependency Mgmt--Bret Brown & Bill Hoffman

Sean Baxter: Safe C++

Safe C++ Sean Baxter

CppCon 2023 Let's Fix Sparse Linear Algebra with C++. It'll Be Fun and Easy! -- Benjamin Brock

CppCon 2023 Implementing Coroutines Using C++17 -- Alon Wolf

CppCon 2023 C++ Memory Model: from C++11 to C++23 -- Alex Dathskovsky

CppCon 2023 Help! My Expression Template Type Names Are Too Long! -- Braden Ganetsky

CppCon 2023 Filling the Bucket: Reading Code, C++ Code Interviews & Exams -- Amir Kirsh

CppCon 2023 Back to Basics: The Rule of Five in C++ -- Andre Kostur

C++ Safety with Herb Sutter

CppCon 2023 Exceptionally Bad: The Misuse of Exceptions in C++ & How to Do Better -- Peter Muldoon

CppCon 2023 You Should Use Address Sanitizer -- Brody Holden

CppCon 2023 Delivering Safe C++ -- Bjarne Stroustrup

CppCon 2023 Cooperative C++ Evolution - Toward a Typescript for C++ -- Herb Sutter

CppCon 2023 ClangFormat Is Not It -- Anastasia Kazakova

CppCon 2023 C++ Modules: Getting Started Today -- Andreas Weis

CppCon 2023 Higher-Order Template Metaprogramming with C++23 -- Ed Catmur

CppCon 2023 File I/O for Game Developers: Past, Present, and Future with C++ -- Guy Davidson

CppCon 2023 Back to Basics: Iterators in C++ -- Nicolai Josuttis

CppCon 2023 Whitespace: A Humorous Short Talk -- Dan Curran

CppCon 2023 C++23: An Overview of Almost All New and Updated Features -- Marc Gregoire

CppCon 2023 A Journey Into Non-Virtual Polymorphism in C++ -- Rudyard Merriam

Pure Virtual C++ 2024 Recordings Available

CppCon 2023 A Fast, Concurrent Data Loader for Time-Series Data -- Glenn Philen

CppCon 2023 Interfaces in C++ -- Megh Parikh

CopperSpice: Declarations Gone Wrong -- Copperspice

Why you shouldn't have virtual member functions with default parameters -- Andreas Fertig

Machine Code Explained -- Matt Godbolt

CopperSpice: Generic vs Meta Programming

Releasing the keynotes of Meeting C++ 2023

Prog C++ - Ivan Čukić - Closing Keynote Meeting C++ 2023

Helping open communities thrive - Lydia Pintscher - Center Keynote Meeting C++ 2023

6 impossible things - Kevlin Henney - Opening Keynote Meeting C++ 2023

Promise-Cpp with Boost.Beast -- Richard Thomson

CopperSpice: Time to Sort Out std::chrono

Safe C++
Sean Baxter