Slides of the 4th of February 2019 BeCPP Meeting

February 10, 2019 Marc Gregoire Events

Thank you everyone for joining the Belgian C++ Users Group meeting on 4th of February 2019 and thanks to Sioux for sponsoring the event by providing the location and catering.

If you couldn’t attend the event in person, or if you would like to go over the material again, you can download them below.

Presentation: “Parsing CSS in C++ with Boost Spirit X3” by Ruben Van Boxem

Presentation: “Using Monoids in C++” by Kristoffel Pirard

Source code for this presentation can be downloaded here.

All material for this presentation is also available on GitHub.

More

0

Pictures of the 4th of February 2019 BeCPP Meeting

February 10, 2019 Marc Gregoire Events

Here are some pictures of the Belgian C++ Users Group meeting held on 4th of February 2019.

More

0

Next BeCPP UG Meeting Planned For February 4th, 2019

December 14, 2018 Marc Gregoire Events

The next meeting of the Belgian C++ Users Group is planned for Monday February 4th, 2019 at 18:00 at Sioux @ Aldhem Hotel (Room d’Artagnan 3 & 4).

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.

We will be giving away 2 copies of Professional C++, the 4th Edition.

We will also be giving away a copy of C++ Standard Library Quick Reference.

And finally, we will also give away a copy of Beginning C++17, From Novice to Professional.

The event is free for everyone, but you need to register for it.

There are 70 seats available for this event.

Note: The deadline for registrations is January 27th, 2019!

Parking

Parking B, behind the hotel, has place for 250 cars with separate entrance for the room d’Artagnan. Parking A in front of the hotel has place for an additional 100 cars.

More

0

Slides of the 25th of October 2018 BeCPP Meeting

October 29, 2018 Marc Gregoire Events

Thank you everyone for joining the Belgian C++ Users Group meeting on 25th of October 2018 and thanks to Altran for sponsoring the event by providing the location and catering.

If you couldn’t attend the event in person, or if you would like to go over the material again, you can download them below.

Presentation: “Writing Standard Library Compliant Data Structures and Algorithms” by Marc Gregoire

Presentation: “Memory Architecture & Performance” by Barry Van Landeghem

More

0

Pictures of the 25th of October 2018 BeCPP Meeting

October 27, 2018 Marc Gregoire Events

Here are some pictures of the Belgian C++ Users Group meeting held on 25th of October 2018.

More

0

Next BeCPP UG Meeting Planned For October 25th, 2018

September 15, 2018 Marc Gregoire Events

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.

We will be giving away 2 copies of Professional C++, the 4th Edition.

The event is free for everyone, but you need to register for it.

There are 80 seats available for this event.

Note: The deadline for registrations is October 21st, 2018!

More

0

Slides of the 28th of June 2018 BeCPP Meeting

July 4, 2018 Marc Gregoire Events

Thank you everyone for joining the Belgian C++ Users Group meeting on 28th of June 2018 and thanks to Western Digital for sponsoring the event by providing the location and catering.

If you couldn’t attend the event in person, or if you would like to go over the material again, you can download them below.

Presentation: “Strongly Typed Declarative Bitsets in C++17” by Ewoud van Craeynest

Presentation: “The Observer pattern and boost.signals2” by Lieven de Cock (Only source code, no slides)

More

7

Pictures of the 28th of June 2018 BeCPP Meeting

July 4, 2018 Marc Gregoire Events

Here are some pictures of the Belgian C++ Users Group meeting held on 28th of June 2018.

More

0

Next BeCPP UG Meeting Planned For June 28th, 2018

June 2, 2018 Marc Gregoire Events

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.

We will be giving away 2 copies of the recently published new edition of Professional C++, the 4th Edition.

We will also be giving away a JetBrains coupons for 100% discount of a 1 year free personal subscription for any single JetBrains tool/IDE JetBrains.

The event is free for everyone, but you need to register for it.

There are 70 seats available for this event.

Note: The deadline for registrations is June 24th, 2018!

More

0