Next BeCPP UG Meeting Planned for January 15th, 2025

17 Dec, 2024 C++, Events

I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Wednesday January 15th, 2025 at 18:00 at Siemens.

Siemens ( https://plm.sw.siemens.com/en-US/simcenter/physical-testing/testlab/ ) is sponsoring this event by providing the location, drinks and catering.

The agenda is as follows:

18:00: Reception with food.
18:30: Session 1: Several easy ways to increase the quality of your code, make them yours (Lieven de Cock)
There are many easy-to-use tools, that help us improve the quality of our code. Nevertheless, there seem to be developers who are not familiar with those tools or don’t use them.
Why ?
If the machine can have our back, with quick feedback loops, we should take advantage of that.
The compiler is your best friend, tweak the warning levels up. Or should we say: compilers are your best friends.
The next step is static analyzers, once again have the machine inspect your code, no personal preferences to discuss in code reviews, the machine won’t budge or become emotional. We will look at cppcheck and clang-tidy.
Also at run time we have a few friends to help us out, the sanitizers do an excellent job at finding issues, we will look at valgrind, UBSAN, ASAN, TSAN.
There are many ways to use these tools, we will look at a way, but there are other ways, find your way in case you don’t like the presented way, as long as you start using the tools.
We will also look at a way to integrate these tools into the cmake/ctest eco-system.
19:30: Break
19:45: Session 2: Why use coroutines for asynchronous applications? (Johan Vanslembrouck)
“The Coroutines TS provided a wonderful way to write asynchronous code as if you were writing synchronous code. You just need to sprinkle co_await at appropriate points and the compiler takes care of suspending the coroutine, preserving state across suspend-points and resuming execution of the coroutine later when the operation completes.” (https://lewissbaker.github.io/2020/05/11/understanding_symmetric_transfer)
An application developer no longer must cut an application into small pieces that do not wait/block internally and that must be stitched together, e.g. using a chain of callback functions or state machines. The C++20 compiler does all the hard work for you now, even for functions with a complex control flow. As a result, you can develop applications much faster, and they are more maintainable than without the use of coroutines.
The presentation will discuss several example programs, comparing a synchronous version with an asynchronous version and a coroutine version. By the end of presentation, I hope you will be convinced that coroutines are a valuable addition to C++ to write responsive, asynchronous applications.
The presentation includes a short introduction to coroutines; no in-depth a priori knowledge of coroutines is necessary to follow the presentation.
20:45: Introduction to Siemens, followed by a drink.