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 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 Tuesday January 24th, 2017 at 18:00 at Nobel Biocare.
Nobel Biocare ( https://www.nobelbiocare.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 C++17, Part 2? (Peter Van Weert) This talk will continue the talk from November 2016, giving an overview of all the new features scheduled to be included in C++17. This second part will focus more on library changes.
19:30: Break
19:45: Session 2: Coming to terms with C++ in a huge financial application (Cosmin Cremarenco) Murex is a large financial application – ~15M lines of code of C/C++. Migrating from C to C++ has come with enormous challenges. Essential components had to be upgraded to what a C++ programmer naturally expects today. A legacy object framework based on C had to be deprecated in favour of C++, the build system had to be upgraded, proper testing put in place, processes devised to how third-party libraries are introduced in our codebase and used and, finally, a performant serialization system that is in-line with today’s expectations on latency and throughput when communicating between components written in different or same programming language.
20:45: Short presentation/demo by Nobel Biocare followed by a drink.
The event is freefor everyone, but you need to register for it.
The next meeting of the Belgian C++ Users Group is planned for Thursday November 24th, 2016 at 18:00 at Nikon Metrology HQ.
Nikon Metrology ( http://nikonmetrology.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 C++17? (Peter Van Weert) This talk will give an overview of all the new features scheduled to be included in C++17.
19:30: Break
19:45: Session 2: Mobile App Development for Multiple Platforms with Visual C++, 2016 (Marc Gregoire) Visual C++ supports mobile app development for Windows, Android, and iOS from a single code base, optionally with a thin platform-specific UI layer. The resulting binaries can be deployed to an emulator or to a real device and debugged on both, all from within Visual C++. This presentation is a follow up of my previous BeCPP presentation, and as such the session will only briefly cover the basics of cross-platform mobile app development. Please view https://www.youtube.com/watch?v=2Y47g8xNE1o or https://channel9.msdn.com/events/CPP/CppCon-2015/CPPConD02V019 for this material in depth. In this follow up, we go over the new features added for cross-platform development since last year. Additionally, we continue where last year’s session ended, and will go deeper on how to write your applications to have a native look-and-feel UI on each of the different platforms.
20:45: Short presentation and guided tour of Nikon Metrology followed by a drink.
The event is freefor everyone, but you need to register for it.
NOTE: Due to a logistics problem, the date has changed. The event will now take place on Thursday June 30th and not on June 23rd!
The next meeting of the Belgian C++ Users Group is planned for Thursday June 30th, 2016 at 18:00 at Newtec.
Newtec ( http://www.newtec.eu/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00: Sandwiches.
18:30: Session 1: Build a database-independent cross-platform persistence layer with Qt (Johan Decorte) Most applications need some kind of persistence. Often relatonal databases are a good choice to store and retrieve data. Besides a cross-platform IDE Qt also provides extensive general-purpose libraries including a database-independent, object-oriented and clean SQL Module API. You can decide even at runtime wether your target database is e.g. Oracle, MS SQL Server or mySQL. Both plain SQL and stored procedure calls are supported.
19:30: Break
19:45: Session 2: Objects? No Thanks! (Wouter van Ooijen) Micro-controller programming can benefit from compile-time polymorphism without paying a run-time price by using static class templates. For small micro-controllers (kilobytes of memory) C++ run-time polymorphism (using objects and virtual methods) is often deemed too expensive in ROM, RAM, and run-time overhead. This talk shows how templates can be used to implement compile-time polymorphism, and static classes to avoid the need for run-time objects. This technique can produce highly modular and composable code that is still as efficient as dedicated C code, but offers better prospects for re-use. This approach is illustrated with an abstraction for GPIO (General Purpose Input Output) pins and ports, with an implementation on an LPC1114 microcontroller, and a number of decorators for pins and numbers.
20:45: Short presentation and guided tour by Newtec.
21:00: Drink
The event is freefor everyone, but you need to register for it.
The next meeting of the Belgian C++ Users Group is planned for Thursday December 3th, 2015 at 18:00 at Selligent.
Selligent ( https://www.selligent.com/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00: Sandwiches.
18:30: Session 1: Move semantics && rvalue references, part 2 (Bert Rodiers) In this presentation we will continue where we left off a year ago. First we will discuss some alternative implementations for the move operators and briefly talk about how to pass arguments. The rest of the talk dives into rvalue references in combination with deduced types and perfect forwarding.
19:30: Break
19:45: Session 2: Cross-Platform Mobile App Development with Visual C++ 2015 (Marc Gregoire) Visual C++ 2015 supports the development of apps for the Windows platform as well as for Android and iOS. A single code base, possibly with a thin platform-specific UI layer, can be compiled to run on Windows, Android, and iOS. The resulting binary can be published to a device and debugged, all from within Visual C++ 2015. This presentation introduces you to such cross-platform mobile app development, including debugging and emulation, and includes a number of demos.
20:45: Short presentation by Selligent.
21:00: Drink
The event is freefor everyone, but you need to register for it.
The next meeting of the Belgian C++ Users Group is planned for Thursday June 18th, 2015 at 18:00 at OM Partners.
OM Partners ( https://ompartners.com/ ) is sponsoring this event by providing the location, drinks and catering.
The agenda is as follows:
18:00: Sandwiches.
18:30:Session 1: The C++ Memory Model and Atomics. (Peter Van Weert) Learn more about the C++ memory model introduced by C++11. Get answers to questions such as what exactly is this C++ memory model? What does it provide and guarantee? What are atomics? How do atomics relate to the memory model? How to use atomics to write thread-safe code? And more.
19:30: Break
19:45:Session 2: Portable C++ File System abstraction (Lieven de Cock) Via the standard library we can open and close files, we can read and write to them, be it old style FILE* or fstream. So content manipulation is available in a portable way. But how about File (and Directory) Management. On Posix you might have done stat, opendir, readdir, closedir, …. Others might be acquainted with Windows Api methods like FindFirstFile, CreateFile, CopyFile, … But nothing portable. There are however several libraries who can bring a lot of such functionality for File and Directory Management. We will look at 2 such libraries, boost::FileSystem and Poco::FileSystem. Finishing up with a sneak peak on the upcoming C++ library standard proposal for File System. So it is time to code in a portable way now, and the future will even be more bright. Get yourself a new HD or SSD because we are managing the files from within the C++ code in a portable way.
20:45: Short presentation by OM Partners.
21:00:Drink
The event is freefor everyone, but you need to register for it.
There are 80 seats available for this event.
CppDepend is also sponsoring this event by providing a number of free licenses for their CppDepend product. When you register for the BeCPP event, there will be a checkbox that you can check if you are interested in such a license. By checking that checkbox you allow us to provide CppDepend with your email address so that they can create your license. We have 23 licenses available on a first-come-first-served basis. These are 20 personal licenses and 3 commercial licenses. From all interested people, 3 will be selected at random to receive a commercial license.
The next meeting of the Belgian C++ Users Group is planned for Wednesday December 17th, 2014 at 18:00 at TOMRA.
TOMRA ( http://www.tomra.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 VC++2015? (Marc Gregoire) An overview of new features and functionality in Microsoft Visual C++ 2015.
19:30:Break
19:45:Session 2: Move semantics && rvalue references, part 1 (Bert Rodiers) In this presentation we will be going deeper into move semantics and rvalue references. A large part of the presentation will talk about how to enable move support, discuss under which conditions it is applied and will point-out some potential pitfalls. We will also discuss Lambda generalized capture, which can be used to capture variables in a lambda expression using move semantics.
20:45:Presentation and/or guided tour of the TOMRA facilities for interested people followed by a drink.
The event is free for everyone, but you need to register for it.
There are 50 seats available for this event.
Note: The deadline for registrations is December 15th, 2014!
The next meeting of the Belgian C++ Users Group is planned for Thursday May 8th, 2014 at 18:00 at Materialise HQ.
Materialise ( http://materialise.be/ ) is sponsoring this event by providing the location, drinks and catering
We will have an international speaker for this event: Artur Laksberg.
Artur Laksberg leads the Visual C++ Libraries development team at Microsoft, responsible for the STL, CRT, C++ AMP, PPL, Casablanca and other libraries. His interests include concurrency, programming language and library design, and modern C++. Artur is one of the co-authors of the ISO C++ proposal on Parallelism (aka Parallel STL) as well as the Concurrency Technical Specification.
If you ever wanted to ask a question to a member of the Visual C++ product team, now is your chance.
The agenda is as follows:
18:00:Sandwiches.
18:30:Session 1: Parallelism in the Standard C++: What to Expect in C++ 17 (Artur Laksberg) It is 2014 and parallel programming has entered the mainstream. No longer is it the domain of the few highly trained experts. The tools available in the C++ today make parallelism accessible – if not yet easy – to average developers. However, writing efficient cross-platform parallel code in C++ is still hard. The standard constructs available in C++ 11/14 are too basic and too low-level. More advanced tools exist, but most are either vendor-specific or don’t work on all platforms. In this presentation, we’ll talk about the joint effort spearheaded by several members of the ISO C++ Committee to bring parallelism into the C++ Standard Template Library. The project known as the “Parallel STL” aims to bring muliticore and SIMD parallelism into the next revision of the ISO C++ Standard.
19:30:Break
19:45:Session 2: Asynchronous programming with futures and await (Artur Laksberg) We have to write asynchronous code for a number of reasons, such as making our GUI apps more responsive, or our server code more scalable. Dealing with asynchrony is hard, perhaps harder than parallelism, and doing it in C++ in a portable way is even harder. If you are familiar with the “callback soup”, “control flow inversion” and other such phenomena, you’ve experienced the pain of asynchrony. In this presentation, we’ll look at the state of the art of asynchrony in C++, discuss futures and continuations, await and resumable functions, and how these concepts are making their way to Standard C++.
20:45:Guided tour of the Materialise facilities for interested people followed by a drink.
The event is free for everyone, but you need to register for it.
On Monday March 17th, 2014 I gave a “What’s new in Visual C++ 2013” presentation for the Belgian C++ Users Group (BeC++).
This time there were around 55 attendees for the BeC++ meeting, quite a success 🙂
The slides of my presentation can be downloaded below:
The next meeting of the Belgian C++ Users Group is planned for Monday March 17th, 2014 at 18:00 at KLA-Tencor / ICOS Belgium.
KLA-Tencor / ICOS Belgium ( http://kla-tencor.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 C++14 (Peter Van Weert) An overview of the new features in the latest C++14 standard.
19:30:Break
19:45:Session 2: What’s new in Visual C++ 2013 (Marc Gregoire) An overview of the new features in Visual C++ 2013 and the Visual C++ 2013 November CTP.
20:45:Short technically oriented presentation by the host KLA-Tencor / ICOS Belgium.
LMS International ( http://www.lmsintl.com/ ) is sponsoring this event by providing the location, drinks and catering.
This time, there will be one speaker, giving two presentations of one hour on one subject. The agenda is as follows:
18:00: Sandwiches.
18:30: Session 1: Strings and String Manipulation in C++, Part 1 (Lieven de Cock) Once there were c-arrays, evolution brought us std::string. This made life easier, and less manual reimplementation was needed because of the power std::string brought to the table. Nevertheless we still keep on reimplementing basic and advanced string manipulation functionality. By this continuously reinventing the wheel we spend a lot of time fixing the same mistakes, while out there are tried and tested and proven libraries. C++11 also brings more power, but we will focus on boost string manipulations. Basic manipulations, like replace, find, erase, split, join, trim, …, next to lexical_cast, boost tokenizer, regex (both boost and std) will be explained and show cased. Next to the lexical_cast we will mention std::to_string. Similar library functionality provided by the POCO libraries will be shown too. String power is at your fingers for free, just say the magic word.
19:30: Break
19:45: Session 2: Strings and String Manipulation in C++, Part 2 (Lieven de Cock)
20:45: Demo of an LMS International software product followed by a drink.
The next meeting of the Belgian C++ Users Group is planned for Wednesday June 12th, 2013 at 18:00 at Nikon Metrology HQ.
Nikon Metrology ( http://nikonmetrology.com/ ) is sponsoring this event by providing the location, drinks and catering.
There will be two international speakers:
Joel Falcou is an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique in Orsay, France. His work focuses on investigating high-level programming models for parallel architectures (present and future) and providing efficient implementation of such models using high-performance language features. He’s an active member of the Boost community and CEO of MetaScale, a French start-up valorizing his research. He is also a member of the ISO C++ Standards Committee.
Jens Weller is a self-employed C++ specialist, working with C++ for over 14 years. He is organizing the C++ conference “Meeting C++” in Düsseldorf, and also runs http://meetingcpp.com. Jens has some vast C++ experience gathered as a freelancer in the IT Industry.
The agenda is as follows:
18:00: Sandwiches.
18:30: Session 1: Qt5 – Multimedia Overview (Jens Weller) The talk will give a short introduction into Qt5, and focus on its Multimedia Framework, showing how to write an MP3 Player or a video recorder in Qt5.
19:30: Break
19:45: Session 2: Boost.Proto (Joel Falcou) C++ Embedded Domain Specific Languages Made Easy.
20:45: Guided tour of Nikon Metrology followed by a drink.
The Belgian community is organizing the 7th edition of Community Day! Community Day 2013 will take place on June 20th 2013 in Utopolis Mechelen.
14 user groups will outperform themselves to bring you their view on Microsoft products in more than 25 sessions. 2013 is not a release year for Microsoft so far, so that gives us, the community, the opportunity to do deep-dive sessions in interesting topics. The biggest goal of this edition is bringing you high-quality sessions. And we’re pretty sure we have achieved that. Why don’t you take a look yourself at our agenda? Oh and don’t forget to take a look at our sponsor page, because it’s thanks to them we can organize this great event!
Convinced you need to be part of the experience again? Want to register? Great! Registration opens in the second week of May so come back soon to reserve your seat. Remember that last year, the event was sold out very fast, so make sure you’re on time!
The next meeting of the Belgian C++ Users Group is planned for Monday February 4th 2013 at 18:30 at Materialise HQ.
Note: The deadline for registrations is January 18!
The agenda is as follows:
Session 1: Effective WinRT with C++ (Francisco Almeida) This will be a brief overview of implementation of Windows Store apps using C++, along with its most useful libraries, new language features and, of course, common pitfalls and traps one may encounter. We will go over the multithreaded design of WinRT, and how modern C++ allows us to effectively cope with it, including exception handling. We will, of course, refresh some general knowledge of Windows Store app development, in the perspective of its implementation while using C++.
Break
Session 2: Threading in C++11 (Lieven de Cock) Threading has been a challenging and non portable job for many years, and it is one of our basic tools for the future. Though several libraries came to aid (POCO / boost / …), now it’s finally part of the language, C++11 is bringing us threading support. In this crash course we will dive into basic uses of std::thread, std::mutex, std::condition_variable, std::atomic, … Life is easier and more portable now, but did we get all we wanted ? And as always, C++ is powerful, providing constructs mere mortals should better not touch, unless you are that 1% of the user base, but most of us are not. We will see simple code examples explaining the std::thread basics. So lock your mutex, wait for your condition variable and atomically spin up that thread, C++11 threading is here for you. Thou shall async till eternity, or untill the future has delivered its promise.
Guided tour of the Materialise facilities.
Drink
Materialise ( http://materialise.be/ ) is sponsoring this event by providing the location, drinks and catering
The event is free for everyone, but you need to register for it.
