Italian C++ Conference 2018--Marco Arena
My report about the last Italian C++ event:
Italian C++ Conference 2018
by Marco Arena
From the article:
On June 23, 200 people swarmed in Milan and attended the Italian C++ Conference 2018...
community
Slides of the 28th of June 2018 BeCPP Meeting -- Marc Gregoire
On June 28th 2018, the Belgian C++ Users Group had their next event sponsored by Western Digital.
Slides of the 28th of June 2018 BeCPP Meeting
About the event:
- "Strongly Typed Declarative Bitsets in C++17" (Ewoud van Craeynest)
- "The Observer pattern and boost.signals2" (Lieven de Cock)
If you couldn’t attend the event in person, or if you would like to go over the material again, you can download them from the BeCPP website.
Registration for Student- and Supporttickets for Meeting C++ 2018 is available
Meeting C++ has opened their programs for attending the conference over the student- and support ticket programs.
Announcing the student and support tickets for Meeting C++ 2018
by Jens Weller
From the article:
The programs for attending Meeting C++ with through a free ticket are back! You can now register for a Student and/or Support ticket.
Also, additionally the application form for the volunteer program is open...
CppCon 2017: Agent based class design--Odin Holmes
Have you registered for CppCon 2018 in September? Early bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Agent based class design
by Odin Holmes
Summary of the talk:
Abstracting a set of functionalities into a class which provides a higher level interface often requires tough design decisions. Users who do not have the exact requirements for which the abstraction is optimized will suffer a syntactic or run time overhead as a result. Alexandrescu's famous "policy-based design" provides a mechanism to allow the user to extend and customize an existing abstraction in order to fine-tune its functionality for many different use cases. This is however limited to use cases where each policy more or less represents a compile time strategy pattern.
Alas, not everything is a strategy pattern. In this talk I will explore the viability of a more agent-pattern-like paradigm where each policy knows its requirements and publishes its capabilities. In this paradigm, glue code connecting any valid set of policies is automatically generated using template metaprogramming. This allows much more powerful customizations while maintaining static linkage.
C++ User Group Meetings in July
Here is the monthly overview on upcoming C++ User Group meetings for July 2018:
C++ User Group meetings in July 2018
by Jens Weller
From the article:
The monthly overview on upcoming User Group meetings!
There are 6 new C++ User Groups: Houston, Prague, Cluj, New York, Braunschweig, Midrand...
CppCon 2017: Concurrency, Parallelism and Coroutines--Anthony Williams
Have you registered for CppCon 2018 in September? Early bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Concurrency, Parallelism and Coroutines
by Anthony Williams
Summary of the talk:
C++17 is adding parallel overloads of most of the Standard Library algorithms. There is a TS for Concurrency in C++ already published, and a TS for Coroutines in C++ and a second TS for Concurrency in C++ in the works.
What does all this mean for programmers? How are they all related? How do coroutines help with parallelism?
This session will attempt to answer these questions and more. We will look at the implementation of parallel algorithms, and how continuations, coroutines and work-stealing fit together. We will also look at how this meshes with the Grand Unified Executors Proposal, and how you will be able to take advantage of all this as an application developer.
CppCon 2017: Objects, Lifetimes, and References, oh my...--Nicole Mazzuca
Have you registered for CppCon 2018 in September? Early bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Objects, Lifetimes, and References, oh my...
by Nicole Mazzuca
Summary of the talk:
How does the C++ abstract machine really work at the lowest levels? Why does the committee design its rules the way they do? Gain insight into the object model of C++, from references to passing semantics to copy elision. C++ is a complicated language full of arcane rules and complicated tangents - learn how it's all tied together in this basic model of locations, objects, and values.
CppCon 2017: Runtime Polymorphism: Back to the Basics--Louis Dionne
Have you registered for CppCon 2018 in September? Early bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Runtime Polymorphism: Back to the Basics
by Louis Dionne
Summary of the talk:
C++ solves the problem of runtime polymorphism in a very specific way. It does so through inheritance, by having all classes that will be used polymorphically inherit from the same base class, and then using a table of function pointers (the virtual table) to perform dynamic dispatch when a method is called. Polymorphic objects are then accessed through pointers to their base class, which encourages storing objects on the heap and accessing them via pointers. This is both inconvenient and inefficient when compared to traditional value semantics. As Sean Parent said: Inheritance is the base class of evil.
It turns out that this is only one of many possible designs, each of which has different tradeoffs and characteristics. This talk will explore the design space for runtime polymorphism in C++, and in particular will introduce a policy-based approach to solving the problem. We will see how this approach enables runtime polymorphism with stack-allocated storage, heap-allocated storage, shared storage, no storage at all (reference semantics), and more. We will also see how we can get fine-grained control over the dispatch mechanism to beat the performance of classic virtual tables in some cases. The examples will be based on a real implementation in the Dyno library [1], but the principles are independent from the library.
At the end of the talk, the audience will walk out with a clear understanding of the different ways of implementing runtime polymorphism, their tradeoffs, and with guidelines on when to use one implementation or another.
CppCon 2017: Fuzz or lose...--Kostya Serebryany
Have you registered for CppCon 2018 in September? Early bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
Fuzz or lose...
by Kostya Serebryany
Summary of the talk:
Fuzzing is a family of testing techniques in which test inputs are generated semi-randomly. The memory unsafety of C++ has made fuzzing a popular tool among security researchers. Fuzzing also helps with stability, performance, and equivalence testing; and it’s a great addition to everyone’s CI.
Our team has launched OSS-Fuzz, the Google's continuous fuzzing service for open source software, and a similar service for our internal C++ developers. Over 1000 C++ APIs are being fuzzed automatically 24/7, and thousands of bugs have been found and fixed.
Now we want to share this experience with the wider C++ community and make fuzzing a part of everyone’s toolbox, alongside unit tests. We will demonstrate how you can fuzz your C++ library with minimal effort, discuss fuzzing of highly structured inputs, and speculate on potential fuzzing-related improvements to C++.
CppCon 2017: dynamic_cast From Scratch--Arthur O'Dwyer
Have you registered for CppCon 2018 in September? Early bird registration is open now.
While we wait for this year’s event, we’re featuring videos of some of the 100+ talks from CppCon 2017 for you to enjoy. Here is today’s feature:
dynamic_cast From Scratch
by Arthur O'Dwyer
Summary of the talk:
This session will introduce you to the C++ object model: the rules by which C++ class objects are translated into memory layouts. We'll quickly cover polymorphic class types and multiple and virtual inheritance. We'll discuss the anatomy of a virtual method call, the difference between `static_cast` and `reinterpret_cast`, and what's contained in a vtable besides function pointers. We'll see that the way `dynamic_cast` thinks about the class hierarchy is slightly different from the way we're used to drawing it; and that `dynamic_cast` is expensive enough that sometimes we can find cheaper ways to ask an object for its type! The climax will be a complete, bug-free, and fast implementation of C++'s built-in `dynamic_cast`, using our own hand-crafted artisanal run-time type information (RTTI).
Attendees will incidentally be exposed to several features of the modern C++ language, including type traits and the `final` qualifier.
This session will mostly be talking about the Itanium C++ ABI, which is the standard on Linux and OS X systems. Mapping these concepts to the MSVC ABI will be left as an exercise for the reader of the project's GitHub repo: https://github.com/Quuxplusone/from-s...