https://schedule.cppnow.org/session/2025/generic-programming-considered-harmful/

In his seminal 1968 paper “Go To Statement Considered Harmful,” Edsger Dijkstra argued that unstructured control flow leads to tangled, hard-to-maintain code. The critique reshaped programming, ushering in an era of structured design that has influenced software development for over 50 years.

Similarly, generic programming is a cornerstone of modern C++, enabling powerful abstractions and highly reusable code. However, it comes at a cost: increased compilation times, cryptic error messages, and cognitive overhead that challenges even expert developers. Has generic programming delivered on its promises, or is it actively undermining progress?

To frame this question, we’ll take an epic journey spanning 15 billion miles, down to 5 nanometers, and across four decades of software development and computing machine evolution. Along the way, we’ll explore how the abstractions we use to write programs have evolved — highlighting some of the successes and the failures. Ultimately we’ll come back back to where generic programming fits into the picture and it’s contributions.

This session will challenge your perspectives of software development and leave you with a lot to reflect on.

Jeff Garland

Jeff Garland has worked on many large-scale, distributed software projects over the past 30+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written C++ networked code for several large systems including the development high performance network servers and data distribution frameworks.Mr. Garland’s interest in Boost started in 2000 as a user. Since then he has developed Boost.date_time, become a moderator, served as a review manager for several libraries (including asio and serialization), administered the Boost wiki, and served as a mentor for Google Summer of Code. Mr. Garland holds a Master’s degree in Computer Science from Arizona State University and a Bachelor of Science in Systems Engineering from the University of Arizona. He is co-author of Large Scale Software Architecture: A Practical Guide Using UML. He is currently Principal Consultant for his own company: CrystalClear Software, Inc.

View The Full Schedule Here

Join Us in Aspen, Colorado USA for C++Now 2025. 45+ Confirmed C++ Sessions, 3 Keynotes & Lightning Talks Await You!

https://schedule.cppnow.org/session/2025/balancing-the-books/

Writing a well-functioning computer program is an exercise in following rules. Complying with the rules is made much easier when a program can verify its own compliance. This is why we write assertions: they express the rules we wish a program to follow in a way that allows the program to verify its compliance.

But assertions are limited to a particular kind of rule: the rule must be parameterized only by the data the program has at hand. Assertions work wonderfully for “don’t divide by zero,” but they struggle with “don’t read from an uninitialized object” or “don’t write past the end of an array,” and fail entirely with “don’t destroy an object twice” or “don’t write to an object from which another thread might be reading.” The information needed to verify compliance with these rules is simply not available.

So let’s make it available! Let’s try writing extra declarations into programs, and recording the information needed to verify compliance with all the rules. This is, of course, what sanitizers attempt to do. But for compatibility, sanitizers rely on a great deal of guesswork, particularly about objects accessed from more than one translation unit. By providing extra declarations, we can make our intent clear and take the guesswork out of verifying code.

These new declarations form a bookkeeping system for our program. By keeping balanced books, we can detect imminent violations of our programming rules, and head off much undefined behavior before it happens. In this lecture, I will explore the details of this bookkeeping system.

Lisa Lippincott
Lisa Lippincott designed the software architectures of Tanium and BigFix, two systems for managing large fleets of computers. She’s currently assistant chair of the numerics study group of the C++ standardization committee. In her spare time, she studies mathematical logic, and wants to make computer-checked proofs of correctness a routine part of programming.

View The Full Schedule Here

Join Us in Aspen, Colorado USA for C++Now 2025. 45+ Confirmed C++ Sessions, 3 Keynotes & Lightning Talks Await You!

Development tools: Past, Present and Future

https://schedule.cppnow.org/session/development-tools-past-present-and-future/

We are tool-using animals.  We create tools to improve our lives.  As software developers, we use tools to make better software. They enable us to do things that we have never done before.  But they also limit the things that we can do.

Marshall Clow
Marshall has been writing code for more than 40 years. He has been writing open source code for 20+ years. He contributes to Boost (since 2002), was the tech lead for libc++ for many years, and was the chair of the Library Working Group of the C++ standards committee.

View The Full Schedule Here

Join Us in Aspen, Colorado USA for C++Now 2024. 50+ Confirmed C++ Sessions, 3 Keynotes & Lightning Talks Await You!

Employing Senders and Receivers to Tame Concurrency in Embedded Systems

https://schedule.cppnow.org/session/employing-senders-and-receivers-to-tame-concurrency-in-embedded-systems/

Concurrency and asynchronicity are notoriously hard in baremetal systems which often provide few abstractions. One core, a few interrupt driven events, and communication that may produce errors or require cancellation and now we have a concurrency beast. Typical approaches range from ignoring the problem to inefficient and hard to maintain implementations. Senders and Receivers offers much in the solution space but is it the silver bullet we have wanted?

This talk shows how to use the Senders and Receivers pattern to solve increasingly more complex problems. We will use Intel’s open source baremetal senders and receivers library as well as other open source packages to build elegant, declarative solutions to historically complex problems. Our target will be an ARM based development board controlling several devices.

While this talk is focused on concurrency in the embedded baremetal domain, the problems addressed and solutions showcased are applicable to many areas. Please join me as we explore how Senders and Receivers can be employed to tame the concurrency beast in event driven systems.

Michael Caisse
Michael started using C++ with embedded systems in 1990. He continues to be passionate about combing his degree in Electrical Engineering with elegant software solutions and is always excited to share his discoveries with others. Michael is a Principal Engineer at Intel where he works with a talented team putting magic into silicon.

When he isn’t fighting with compilers or robots, he enjoys fencing with a sabre.

View The Full Schedule Here

Join Us in Aspen, Colorado USA for C++Now 2024. 50+ Confirmed C++ Sessions, 3 Keynotes & Lightning Talks Await You!