I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday October 8th, 2024 at 18:00 at Dekimo.*
Dekimo ( https://www.dekimo.com/ ) 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: Better Threading in C++20 (Lieven de Cock) We got threading support by the language and library in C++11. There were however a few things missing, like RAII for a thread object, or a nice way to stop a thread, or to request it to stop. Similar problem, how do we stop a ‘waiting’ condition variable. Most developers have solved these problems with home made solutions. C++20 brings standardized solutions to the table.
Next to that we also get some new synchronization facilities like barrier/latch/semaphore, all nice additions. There is no longer a need to re-invent the wheel or reach out to 3rd-party libraries. We will look at all these new little tools and investigate on how to use them. So register your stop callback, and by the end of the talk we will request our source to stop, and in our ‘cooperative cancellation’ scheme, do not forget to keep an eye on your stop token.
19:30:Break
19:45:Session 2: Fibers: CoRoutines from the OS (Dave De Breuck) This talk delves into fibers in C++, focusing on their role in enhancing concurrency and efficiency. Fibers use cooperative context switching, making them ideal for high-concurrency applications. We’ll explore the principles of fibers, their advantages over traditional threads, and their implementation in C++.
20:45:Introduction to Dekimo, followed by a drink.
The event is freefor everyone, but you need to register for it.
There are 75 seats available for this event.
Note: The deadline for registrations is October 1st, 2024!
*There are limited number of parking places available at the location itself. However, there are free parking places available on the Brusselsesteenweg and in the streets around the office. Additionally, the free P+R parking Gentbrugge Arsenaal is at 1km with a tram connection to the office. There is a bus stop and a tram stop in front of the office.
Pure Virtual C++ is a free one-day virtual conference for the whole C++ community. This year it will run on April 30th 15:00 UTC. Sign-up for free to get access to five sessions on the day and a host of pre-conference content.
Here is the list of sessions:
Automated Testing of Shader Code with Keith Stockdale (Rare) – Rare has a rich culture of writing automated tests for their game and engine code. The ‘Sea of Thieves’ project has hundreds of thousands of automated tests that exist to validate behavior and to ensure that bugs are kept to a minimum, as we continually deliver an ever-changing experience to players. Among this large test suite are tests that validate and verify shader code. This session explores the new Rare Shader Test framework, describing how tests are written for shader code. The talk will also delve into the C++ and HLSL implementation of the shader testing framework to discuss the design goals of the system, and how we are using C++ to meet these design goals.
Message Handling with Boolean Implication with Ben Deane (Intel) – Message reception and dispatch is something common to many codebases. This talk shows the unreasonable effectiveness of going back to basics and really understanding and unlocking the power of Boolean algebra in the design of a message handling library. We’ll talk about composing predicates on messages and manipulating them at compile time in order to do the least work when dispatching them at runtime. Particularly we’ll introduce implication, develop an intuition for this lesser-used Boolean operation, and see how it is key to a generic approach for simplifying predicates.
I Embedded a Programming Language In Debug Information with Sy Brand (Microsoft) – DWARF information on Linux provides debuggers with a bridge between high-level source code and the machine instructions generated by the compiler. As part of this, it describes how to locate variables within your program at runtime using a language called DWARF Expressions. When implementing a parser for DWARF Expressions I thought “this seems suspiciously Turing-complete, can I implement a programming language inside this?” It turns out the answer is yes. In this session you’ll learn how debug information and executables are stored on Linux systems and how I managed to (ab)use them to implement a programming language interpreter that runs when you ask your debugger for the address of a variable.
Enhancing C++ development with Copilot Chat with Sinem Akinci (Microsoft) – Copilot is an AI-powered pair programmer integrated into Visual Studio and VS Code that can be there to assist you at many different points in your C++ development journey. In this session, we’ll introduce Copilot and Copilot Chat, share tips for achieving the results you want, and provide different use cases for using these tools. Then, we’ll see these tools in action in C++ code in Visual Studio as we tackle a variety of problems from navigating and understanding code to refactoring existing code.
Progress Report: Adopting Header Units in Microsoft Word with Zachary Henkel (Microsoft) – Microsoft Office is a huge C++ codebase with nearly 100 million lines of native code. This size provides a constant challenge to build the product as quickly as possible. C++20 header units are a way to receive many of the benefits of modules, while still working with a codebase originally designed for classic header inclusion. At CppCon 2022 we announced that Office would investigate header units with the goal of improved build throughput. We’re excited to present the results of that work for the benefit of the C++ community at large. In this session, we’ll share build performance metrics for the first time.
I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Monday April 8th, 2024 at 18:00 at Attentia.
Attentia ( https://www.attentia.be/ ) 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: Building a class for modular arithmetic (Toon Baeyens) Writing modern C++ is not easy. Yet, doing it well brings you many benefits. The code will be elegant, and the program will be fast.
In this talk, we will be building a type for modular arithmetic as an excuse to discover many powerful features and techniques within the C++ ecosystem.
This adventure will take us from concepts, metaprogramming, and dependent types to integer division, studying generated assembly and micro-benchmarking.
19:30:Break
19:45:Session 2: Using C++ in the cloud using the AWS C++SDK (Hans Klabbers) Have you ever wondered what cloud computing and serverless provide you as a software developer that creates software with C++? During this talk you will get insight in Amazon Web Services a.k.a. AWS Cloud. A demo of a serverless solution created with AWS services and software built with C++ will be shown during the talk.
20:45:Introduction to Attentia, followed by a drink.
I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday October 31st, 2023 at 18:00 at DAE and Howest (Howest, Campus Kortrijk Weide – The Penta).
18:30:Session 1: Elevating Precision in C++: A Journey below the Surface of Floating-Point (Tom Tesch) Floating-point numbers, with their varying levels of precision, serve as foundational components in the toolkit of both new and seasoned C++ developers. In this presentation, we will uncover the inner workings of floating-point variables, explore their limitations, and discuss strategies for extending precision while being mindful of associated trade-offs. Join us as we embark on a journey into the realm of floating-point arithmetic in C++, offering insights that will enhance your programming finesse.
19:30:Break
19:45:Session 2: Coroutines: Don’t try this at home (Lieven de Cock) In C++20 we got the core language feature “coroutines”. Mostly oriented to the advanced c++ programmers, and not for the mere mortals, since it requires a lot of boilerplate one would not like to write. It provides the fundamentals to further build upon. Unfortunately the STL library did not build on it yet, more was to come in C++23.
In C++23 we will only get one follow up: std::generator.
So let’s revisit coroutines. What are they? A function that can be suspended and resumed. Easily said, but how to make use of it and write that boilerplate after all. We will look at the coroutine from 2 different angles: the user code and the compiler, and we will inspect what each wants or would like to have, and where we need to glue them together and what is needed for that purpose. We will give insights on topics like: coroutine frame, couroutine handle, promise_type, the interface or api.
And if time permits we will look at an example of coroutines in use in asynchronous code (because a misconception is that coroutines (purely) have to do with threads and async’s).
20:45:Introduction to DAE and Howest, followed by a drink.
The event is freefor everyone, but you need to register for it.
There are 250 seats available for this event.
Note: The deadline for registrations is October 29th, 2023!
I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Thursday May 11th, 2023 at 18:00 at Twikit.
Twikit ( https://www.twikit.com/ ) 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: C++23 – What’s in it for You? (Marc Gregoire) C++23, the next release of the C++ standard, introduces new features to the core language and to the Standard Library. This session will bring you up to date with the latest features coming with this new release.
The session includes core language topics such as consteval if statements, multidimensional subscript operators, decay copy, unreachable code, and more. New Standard Library features that will be shown include monadic operations for std::optional, std::flat_map, std::flat_set, a stacktrace library, changes to the ranges library, improvements to std::format, std::expected, and many more.
19:30:Break
19:45:Session 2: Emscripten, what and how? (Dave De Breuck) This talk will give a brief introduction of Emscripten itself and explain how Emscripten, an LLVM-based compiler, converts C++ to JavaScript, which lets you run a C++ codebase on the web at near-native speed.
20:45:Introduction to Twikit, followed by a drink.
The event is free for everyone, but you need to register for it.
There are 60 seats available for this event.
Note: The deadline for registrations is May 9th, 2023!
I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday January 17th, 2023 at 18:00 at Medicim / Envista.
Medicim / Envista ( https://www2.medicim.com/ ) 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: Constraints and Concepts (Peter Van Weert) This presentation consists of two parts: First, I explain how you can, and more importantly should, constrain your template arguments using requires clauses and, typically, concepts. Doing so results in more readable compilation errors, self-documenting template definitions, and easier, more expressive template specialization. Next, I show how you can define your own concepts using the new syntax introduced in C++20. Quite some new syntax to learn, for sure, but you’ll quickly see that constraints and concepts are far easier to master (or at least understand) than the more advanced SFINAE techniques (std::enable_if_t, std::void_t, …) they essentially supersede.
19:30: Break
19:45: Session 2: Space Invaders: The Spaceship Operator is upon us (Lieven de Cock) Before C++20 we had to write 6 comparison operators for our user defined types (or even more). For sure, a tedious task. All this gets simplified with the introduction of the spaceship operator. What happens to your code, when you turn on “-std=c++20” even before we go near the spaceship operator, did your build break? Why does that happen? We will first investigate, another new feature of C++20, the rewriting rules, and how that impacts your code base. And then we will dissect the spaceship operator, from a using perspective, and from an implementation perspective. Oh yes, comparison categories, what are those, and why are these important with respect to the spaceship operator? All will be answered, what initially looked so simple, does require some extra thoughts it seems to correctly use the tool.
20:45: Introduction to Medicim / Envista, followed by a drink.
After a long break due to the Corona pandemic, I’m happy to announce that the next meeting of the Belgian C++ Users Group is planned for Tuesday June 28th, 2022 at 18:00 at Vandewiele Experience Center.
Vandewiele ( https://www.vandewiele.com/ ) 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: Minimal Logging Framework in C++ 20 (Koen Poppe) As developers, adding log statements seems easy and risk-free. However, with hundreds of machines, collecting those log files can become quite a challenge, let alone making sense of the important information they contain. We set out to reduce logging to its essentials and explore optimisations not only in terms of disk space, but also runtime performance and even exposure. Leveraging ideas from well-known software related workflows, we will write a C++20 logging framework from scratch and highlight some surprises along the way.
19:30:Break
19:45:Session 2: Modern CMake (Lieven de Cock) CMake is a cross-platform open source software for managing the build process in a portable fashion. We will have a look at the basics of modern CMake. The old, pre modern cmake way should be considered obsolete, for very good reasons. We will talk about targets, build types, dependencies, usage specifications, …, a quick look on cross compilation, and using 3rd party libraries.
20:45:Introduction to Vandewiele, followed by a drink.
The next meeting of the Belgian C++ Users Group is planned for Thursday June 24th, 2021 at 18:00 and will be held online through Microsoft Teams.
The agenda is as follows:
18:00: The Teams meeting will start to give people plenty of time to join.
18:30: Session 1: A new way of formatting in C++20, are we getting there in the end? (Lieven de Cock) We will have a look at the problems the (s)printf family has brought upon us for decades, how iostreams tries to solve this in an unfriendly way, and how we can now have the best of both worlds, with the upcoming C++20 std::format (or for now with the reference implementation fmt::format).
19:30: Session 2: Understanding value categories in C++ (Kris van Rens) In C++ today, do you know what an xvalue is? Or a prvalue? Why would you want to know? Because it matters! In C++, each expression is characterized by a value category. These value categories are used to describe parts of the C++ standard, and are often used in books and articles. You might have heard of terms like ‘lvalue’ or ‘rvalue’, which are the most commonly known ones. Over the years, changes to the C++ language changed the meaning of value categories. This means a lot of information about value categories is outdated or just plain wrong. In this talk, I will explain what expression value categories are in today’s C++ standard. It turns out that knowledge about value categories can really be beneficial. Not only will it enrich your understanding of C++ in general, it will deepen your understanding of mechanisms like move semantics. Also, it can help you to make better choices about code. These choices can then leverage language rules to enable compilers to generate efficient code without redundant copies. Other, related topics that will be covered: copy elision, return value optimization, temporary materialization.
The event is freefor everyone, but you need to register for it.
There are 300 seats available for this event.
Note: The deadline for registrations is June 23rd, 2021!
I’ll be giving two sessions this year at CppCon 2020:
A keynote session titled “C++20: An (Almost) Complete Overview”: The technical work on C++20 was finished in January 2020, and is now being pushed through ISO certification. This presentation gives an overview of (almost) all new features in both the language and the Standard Library. Some more exotic features will be left out. New language features include modules, coroutines, concepts, templated lambdas, constexpr changes, designated initializers, the spaceship operator, string literals as template parameters, feature test macros, conditional explicit, immediate functions, and more. The second part of the session discusses the changes to the Standard Library. This includes topics such as ranges, atomic smart pointers, cancellable threads, a synchronization library, calendars, time zones, span, a formatting library, features test macros, and more. The material is mostly the same as the “C++20: What’s in it for you?” session from CppCon 2019, but it has been updated with the final standard. If you want a complete overview of all C++20 features, including references to other more deep-dive sessions at CppCon 2020 on certain topics, then this session is for you.
And a session titled “C++20 String Formatting Library: An Overview and Use with Custom Types”: C++20 introduced a nice formatting library with std::format(). This session will explain what the formatting library provides, how to use all of its functionality, and most importantly, how you can customize it so that you can use formatting strings that include your very own custom types and custom formatting parameters, and of course, how to handle errors.
I’m thrilled to announce that I’ll be giving a keynote presentation at this year’s CppCon. Here is the official announcement 😎
The title of my keynote talk is “C++20: An (Almost) Complete Overview”. C++20 is going be discussed quite a bit at this year’s conference and in addition to providing an overview of the new language/library changes, I will guide attendees to other CppCon talks related to C++20.
If you want a complete overview of all C++20 features, including references to other more deep-dive sessions at CppCon 2020 on certain topics, then this session is for you.
After this talk, you should have the confidence and familiarity you need to embrace the latest version of C++.
Part of the abstract:
This presentation gives an overview of (almost) all new features in both the language and the Standard Library. Some more exotic features will be left out. New language features include
This event is cancelled in light of the current state of the Covid-19 outbreak.
We will try to get our two international speakers, Greg and DeWang, back to Belgium at a future event.
The next meeting of the Belgian C++ Users Group is planned for Monday March 30th, 2020 at 18:00 at KU Leuven Department of Computer Science. The welcoming and reception takes place at Foyer Computerwetenschappen (room 00.191), while the sessions will take place in Auditorium Erik Duval (room 00.225)
18:30: Session 1: Amazing tricks with the GDB debugger (Greg Law) If you’re writing C++ for anything other than Windows, chances are
that you occasionally break out GDB. This session presents some of the
lesser known features of GDB that can change the way you debug. GDB has
come a long way in the last few years and now does so much more than
break, print, step and continue. Reversible debugging; Non-Stop Mode;
Multi-process Debugging; and Dynamic Printf are but some of its best
features, and its built-in Python scripting is particularly powerful.
Join Undo co-founder and CEO, Greg Law, as he takes you through a series
of demos to show some amazing tricks with GDB and some of its powerful
new (and not-so-new) features that you may not have heard of.
19:15: Session 2: Static analysis and Coverity (DeWang Li) The C/C++ code you create plays such a pivotal role on our planet,
and as such, companies are investing heavily into ensuring they are safe
and robust. One of the disciplines they invest in to ensure that is
static analysis. DeWang will explain the fundamentals of static
analysis, and using his favorite product, Coverity, demonstrate some of
its capabilities. He will share stories from working with some of the
top Silicon Valley companies and how they apply Coverity.
19:55: Break
20:10: Session 3: Interactive discussion on pointers (Lieven de Cock) Let’s have an exchange of thoughts on the topic of pointers: raw
pointers, smart pointers, std/boost::optional and
std::reference_wrapper.
How to express intent and how to avoid checking things that might not be needed to check?
We will present some use cases to get the discussion going. This is an
interactive session, so start thinking about questions or opinions you
might have.
20:50: Introduction to Dekimo, and KU Leuven Department of Computer Science, followed by a drink.
The next meeting of the Belgian C++ Users Group is planned for Wednesday January 29th, 2020 at 18:00 at OMP.
OMP ( https://www.omp.com/ ) 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: Coroutines in C++20 (Johan Vanslembrouck) A coroutine is a function that can suspend execution to be resumed
later. Coroutines allow for sequential code that executes asynchronously
(e.g. to handle non-blocking I/O without explicit callbacks), and also
supports algorithms on lazy-computed infinite sequences and other uses.
Unlike most other languages that support coroutines, C++ coroutines are
open and not tied to any particular runtime or generator type and allow
libraries to imbue coroutines with meaning, whereas the compiler is
responsible solely for efficient transformation of a function to a state
machine that is the foundation of the coroutine.
The presentation will explain the C++ coroutines mechanism, i.e. code
generated by the compiler and the code to be written by a coroutine
developer. The presentation includes examples of an client-server
application using Boost ASIO in combination with C++ 20 coroutines and a
producer-consumer queue implemented with and without coroutines.
19:30: Break
19:45: Session 2: The evolution of the C++ Lambda (Lieven de Cock) Before C++11, we had to write function objects (functors) or free
standing functions to pass as the callable to several algorithms (for
example: for_each). The drawback was that we were introducing objects in
a bigger scope than actually needed, and it can be considered as rather
some boilerplate.
With the introduction of the lambda we can write (little) callables at
the moment we need them. Over the years (or better said over the new
standards) the lambdas gained extra power and became more user friendly.
In this talk we will have a look on the evolution of the lambda since
its birth in C++11.
The next meeting of the Belgian C++ Users Group is planned for Thursday October 10th, 2019 at 18:00 at Brabanthal (room Luna).
think-cell ( https://www.think-cell.com/ ) 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: C++20: What’s in it for you? (Marc Gregoire) With the current three-year pace of C++ releases, the next release is scheduled for 2020, C++20. This presentation gives an overview of what you can expect in the new standard. It starts with discussing the C++20 language features that will be added by the C++20 standard, such as concepts, coroutines, templated lambdas, the spaceship operator, pack expansion in lambda captures, string literals as template parameters, extra initializer for range-based for loop, modules, and more. Next, we’ll delve into the new Standard Library features, such as ranges, std::span, atomic smart pointers, and more. Depending on the outcome of the next C++ Standard Committee meeting, the list of new features might include improved futures, task blocks, and text formatting. If you want a concise overview of what the C++20 standard will offer, then this presentation is for you.
19:30: Break
19:45: Session 2: From Iterators To Ranges — The Upcoming Evolution Of the Standard Library (Arno Schödl) Pairs of iterators are ubiquitous throughout the C++ library. It is generally accepted that combining such a pair into a single entity usually termed Range delivers more concise and readable code. Defining the precise semantics of such Range concept proves surprisingly tricky, however. Theoretical considerations conflict with practical ones. Some design goals are mutually incompatible altogether.
20:45: Introduction to think-cell, followed by a drink.
The second Belgian LLVM Meetup will take place at the Guardsquare offices in Leuven, the 19th of June. Anyone who’s working with, or is simply interested in, the LLVM project or any of its tools; Clang, lldb, lld, Polly,… is invited. The evening starts off with three short talks on various LLVM related topics. Afterwards, there will be plenty of time to exchange experiences and get to know the local LLVM community.
Schedule:
20h00: Arrival
20h30: Talks ( +- 20min each )
Just compile it: High-level programming on the GPU with Julia.
Sim: a contract-based programming language for safety-critical software.
Processing complete iOS applications on top of LLVM.
The next meeting of the Belgian C++ Users Group is planned for Wednesday July 3rd, 2019 at 18:00 at CluePoints @ OFFBar | ONSpace.
CluePoints ( https://cluepoints.com/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00: Sandwiches.
18:30: Session 1: What’s new in Visual C++ 2019? (Marc Gregoire) Microsoft Visual Studio 2019 and Visual C++ 2019 come with a host of new features. In this session, we will have a look at the important changes and improvements for C++ developers.
19:30: Break
19:45: Session 2: Statistical Scientific programming: challenges in converting R to C++ (Olivia Quinet) Scientific programming is in itself a challenge due to several concomitant issues and requirements including low response time, low memory usage, minimizing numerical errors, error propagation. R is a programming language for statistical computation providing a wide set of packages for linear and non linear modeling, statistical tests, … This talk will focus on the different Object-Oriented strategies implemented to overcome those challenges, speed up the computation while reducing the memory footprint.
20:45: Introduction to CluePoints, followed by a drink.
Sioux ( http://www.sioux.eu/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00: Sandwiches.
18:30: Session 1: Parsing CSS in C++ with Boost Spirit X3 (Ruben Van Boxem) Reading and writing is a fundamental part of programming. Even more so in C++, as it is a relatively low-level language. If not hand-written from scratch, C++ programmers often resort to parser generators such as Antlr, Bison, byacc, Flex, and many others. The former option increases maintenance burden, as the code involved is usually not trivial and error-prone. The latter option complicates the build setup and one loses a certain degree of flexibility in how the parser can be handled.
The authors of Boost.Spirit approached this dichotomy, shook it up a bit, and came up with something better. Boost Spirit, already at its third iteration of implementation, harnesses the C++ language and its generative power to enable us to write parser grammar in C++. This allows for the flexibility of using C++, combined with full control of what is parsed how, while maintaining the simplistic abstract representation of what is being parsed. The latest iteration, X3, employs techniques made possible by C++14 to simplify its implementation, to decrease compile times whilst providing the same flexibility of previous versions. I intend to give a general introduction, followed by a partial implementation of a CSS parser, and hope the power of Boost Spirit can convince you to at least give it whirl.
19:30: Break
19:45: Session 2: Using Monoids in C++ (Kristoffel Pirard) Effective coders recognise tedious repetition and transform it into reusable patterns. Frameworks, libraries and design patterns arise from it. After the GoF Object Oriented patterns, today we are also learning from the functional programming world. One of the patterns they bumped into is the Monoid: it has its application in addition, accumulation, concatenation, you name it. And it’s a simple one.
This talk is about how Monoids seem to be everywhere, and how recognising them has influenced my daily practice. It will show a glimpse of the land of functional design patterns and look at practical aspects of using Monoids in C++. I believe it’s important. And I believe there’s a lot more to be discovered.
20:45: Introduction to Sioux, followed by a drink.
The next meeting of the Belgian C++ Users Group is planned for Thursday October 25th, 2018 at 18:00 at Altran.
Altran ( http://www.altran.com/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00: Sandwiches.
18:30: Session 1: Writing Standard Library Compliant Data Structures and Algorithms (Marc Gregoire) The C++ Standard Library provides a lot of data structures, but it cannot provide every possible data structure or algorithm that you might need. So, sometimes, you might find the need to write your own data structure or algorithm. Since you are writing them yourself, you could give them any interface that suits you. However, wouldn’t it be better to make them compliant with the Standard Library? That way, when you write your own algorithm, you will be able to use that algorithm independently of the type of the container that contains the data for your algorithm. Similarly, if you write a Standard Library compliant data structure, then you will be able to use Standard Library algorithms on the data in your own data structure.
It’s clear, there are a lot of advantages in making your data structures and algorithms compliant with the Standard Library. We’ll first develop a simple algorithm with our own interface. Then we’ll look into what changes we have to make to transform the interface to be Standard Library compliant. Finally, we’ll demonstrate our adapted algorithm by running it on data in a variety of Standard Library containers.
In the last part of the presentation we’ll crank it up a notch. We’ll start by writing our own data structure, initially without thinking too much about the Standard Library. Then we’ll look at an overview of the different sets of requirements that the Standard Library imposes for the different types of containers (sequential, associative, and unordered associative). Finally, we’ll adapt our data structure step-by-step to transform it into a Standard Library compliant data structure. This of course includes writing a suitable iterator. Finally, we’ll demonstrate the transformed data structure by running Standard Library algorithms on the data in it.
19:30: Break
19:45: Session 2: Memory Architecture & Performance (Barry Van Landeghem) The impact of memory architecture on performance is something which every developer should be aware of. In general improving your code performance is already hard and complex. Computer cache memories have led to introduce a new complexity measure for algorithms and new performance counters for code.
In this talk we’ll see what data locality is all about and why using data locality can be a great tool for a developer to boost the performance of his/her algorithms/data structures.
At the end we’ll also at the implications towards parallelism (false sharing/NUMA,…).
20:45: Introduction to Altran, followed by a drink.
The next meeting of the Belgian C++ Users Group is planned for Thursday June 28th, 2018 at 18:00 at Amplidata.
Amplidata, a Western Digital company, ( http://amplidata.com/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00:Sandwiches.
18:30:Session 1: Strongly Typed Declarative Bitsets in C++17 (Ewoud van Craeynest) The C++ standard states that bool values behave as integral types, that they participate in integral promotions and conversions.
As a community, we reached the consensus that those integral types aren’t particularly type safe. So, neither are our bools, neither are our bitsets, nor the bits within a bitset. Numbers just being numbers can lead to subtle bugs and impede merciless refactoring.
This session aims to introduce a strongly typed, declarative bitset type using C++17, by looking at a strongly typed bool and template offset bitfields first.
19:30:Break
19:45:Session 2: The Observer pattern and boost.signals2 (Lieven de Cock) The Observer pattern, is one of the many famous GOF design patterns. We will take a look at a minimal implementation, and then enhance that implementation a bit. We briefly touch some potential problems and think about options on how to deal with them. Then we look at a way of avoiding boiler plate code, by using the boost.signals2 library. This header-only boost library will take care of much administration work so we don’t need to reinvent the wheel. No prior knowledge is needed of the observer design pattern, nor the boost.signals2 library.
Just bring your C++ (11-14-17) skills and … observe.
20:45:Introduction to Amplidata, followed by a drink.
Nokia ( http://nokia.be/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00:Sandwiches.
18:30:Session 1: Boost.Asio C++ (Network) Programming (Part 2) (Lieven de Cock) Boost.Asio is a cross-platform C++ library for network and low-level I/O programming, either using a synchronous or asynchronous model. We will examine this powerful library in 2 sessions.
In this second session we will pick up where we left of, after connecting as a client we will start interacting with the server, and we will see how to implement a server application.
We will do this both in a synchronous and an asynchronous way, keeping an eye on scalability.
Note that the C++ Standard networking proposals are based directly on Boost.Asio, so next to learning this great library we are also preparing for the future C++ standard.
19:30:Break
19:45:Session 2: A possible future for embedded (Odin Holmes) Through the much-hyped advent of Industry 4.0 and IoT, billions of new bare metal devices will be connected to the internet or intranets and will be expected to talk to each other, even across company boundaries. This presents a plethora of new challenges, many of which share a common root; it is crucial that we build a foundation for code reuse and encapsulation of expertise in this domain. What does cross-platform code really mean when we are targeting thousands of ‘platforms’? When encapsulating expertise, we implicitly make assumptions about user code and user code implicitly makes assumptions about library code. What are valid assumptions? What is the basic interface? In this talk I will present a possible future for bare metal development which attempts to answer these questions.
