Meetup at ASML with Klaas van Gend and Odin Holmes

Introduction
Together with ASML we organise a new meetup. We will have two speakers at this Meetup. Klaas van Gend and Odin Holmes. See below for details.

When attending the meetup you need to present a government issued ID with photograph (passport, ID card or drivers license). In case you need a parking spot you have to provide a licence plate number before Tuesday 4 June. Registration for this meetup is possible until Tuesday 4 June!

Agenda
17:00 - Welcome attendees
17:30 - Dinner
18:00 - Talk by Klaas van Gend
19:00 - Short break
19:15 - Talk by Odin Holmes
20:15 - Drinks

Klaas van Gend
Bio
A mechanical engineer by education, he started his working career in 1998 at Sioux controlling wide format inkjet printer prototypes. He went from control engineering to full-blown software engineering to operating system design.
Worked 7 years at MontaVista Linux, involved in many product designs, including TVs, gas chromatographs, video servers, networking equipment, car radios, telephones, payment terminals, and inkjet printers.
Worked 6 years at Vector Fabrics, providing programmer's tooling to find parallelism, performance optimizations, and bugs. Klaas co-designed and taught the Multicore Programming in C++ training.
After Vector Fabrics' demise, Klaas came back to Sioux and has been working at Thermo Fisher Scientific since. In addition to software design, he also took on the "Scrum Master" duties.
At Stack Overflow, Klaas has 1000+ points, mostly on C++, OpenMP, performance and memory issues.

When not working and the sun is shining, you'll find Klaas near sailplanes.
When no sun is to be seen, Klaas likes board games, books, 3d printing, programming games, and movies.

Abstract
In 2024, multicore software should be easier to write than ever. Modern programming languages such as Scala and Rust are maturing, programming frames are getting easier to use and C# and good old C++ have been embracing parallelism as part of their standard libraries.

In C++, parallel versions of most algorithms were already introduced as far back as 2017. These include initializing, sorting, accumulating and transforming. Seemingly free performance boosts that are easy to apply: just provide an “execution policy”. But, running on a big multicore machine, why don’t you get the expected speedup?

Adding parallel execution often only runs a little or no faster at all on a multicore processor. And to make matters worse, all kinds of elusive errors tend to pop up.

Klaas van Gend shows some valid use cases for using the parallel algorithms and some other features from C++11 to C++20. He discusses implementation details in the various popular compilers: gcc, clang, and visual studio.

To get true benefits from multicore systems, the software architecture likely must change. Introducing some appropriate Parallel Patterns can help streamline development and limit exposure of developers to low-level problems like data races, or deadlocks. Parallel Patterns allow the developers to discuss their designs at a higher level and focus on their real problems: handling large amounts of data, complex calculations or transformations, or fast non-blocking event handling. Klaas will discuss some parts of Berkeley’s Parallel Pattern Language and their benefits.

Odin Holmes
Bio
Odin Holmes has been programming bare metal embedded systems for 15+ years, and as any honest nerd admits, most of that time was spent debugging his stupid mistakes. With the advent of the 100x speedup of template metaprogramming provided by C++11 his current mission began: teach the compiler to find his stupid mistakes at compile time so he has more free time for even more template metaprogramming. Odin Holmes is the author of the kvasir::bit library, a DSL which wraps bare metal special function register interactions allowing full static checking and a considerable efficiency gain over common practice. He is also active in building and refining the tools needed for this task such as the brigand MPL library and the kvasir::mpl. He is also the co-founder of the [http://embo.io](https://t.co/QtBw2aZsKQ)embedded software conference as well as CTO at the AIGruppe which designs and produces custom hard and software for industrial monitoring systems.

Abstract
The state of the /*union*/ variant I'm not convinced that std::variant is done. After a brief summary of key design decisions and other work in the same problem space I will highlight where I have had difficulties with the current std::variant in my code and explore alternative implementations that may work better. I will present a strategy for the positional association of variant alternatives with corresponding functions as opposed to a classic overload set approach to visitation. I will discuss its pros and cons in different scenarios as well as how to model things as variants for which current state of the art is lacking modeling power