__cplusplus User Group issueshttps://git.gsi.de/SDE/cxx-user-group/-/issues2021-10-21T06:54:29Zhttps://git.gsi.de/SDE/cxx-user-group/-/issues/1Lambda expressions2021-10-21T06:54:29ZMatthias KretzLambda expressionsMeeting 21-42m.alfonsim.alfonsihttps://git.gsi.de/SDE/cxx-user-group/-/issues/3Modern C++: how inheritance and virtual functions fell out of fashion2021-10-07T13:06:27ZMatthias KretzModern C++: how inheritance and virtual functions fell out of fashionC++ experts seem to agree that the need for inheritance and virtual functions has declined, while solutions based on generic functions and classes have become more and more important.
The talk should compare OO and generic programming pa...C++ experts seem to agree that the need for inheritance and virtual functions has declined, while solutions based on generic functions and classes have become more and more important.
The talk should compare OO and generic programming paradigms and how C++ supports both of them. The performance and maintenance aspects should be discussed. Most importantly examples should compare the different approaches.Meeting 21-40Matthias KretzMatthias Kretzhttps://git.gsi.de/SDE/cxx-user-group/-/issues/8std::span — getting rid of pointer and size2022-05-16T07:43:16ZMatthias Kretzstd::span — getting rid of pointer and sizeC++ does not support passing around variably sized arrays by value. The closest is to pass `std::vector<T>`. But you don't always have your data in the exact `std::vector<T>` chunks to make that a viable interface. So instead, we pass a ...C++ does not support passing around variably sized arrays by value. The closest is to pass `std::vector<T>`. But you don't always have your data in the exact `std::vector<T>` chunks to make that a viable interface. So instead, we pass a pointer to the start of the array and an integer to tell the function how many elements after the pointer are valid array accesses. Example: you have a `vector<int> data` and want to pass the elements from index `n` to `n+16` to a function. `std::span` abstracts this use case and integrates more or less into the APIs of the C++ standard library.Meeting 22-18a.krimma.krimmhttps://git.gsi.de/SDE/cxx-user-group/-/issues/20Static Analysis Part II: custom `clang-tidy` checks2022-05-18T15:37:12ZDennis Kleind.klein@gsi.deStatic Analysis Part II: custom `clang-tidy` checks* AST
* clang's `libTooling` API
* Invoke compiler
* Check anatomy: Matcher, Diagnostic, Fixit
* Example walkthrough* AST
* clang's `libTooling` API
* Invoke compiler
* Check anatomy: Matcher, Diagnostic, Fixit
* Example walkthroughMeeting 22-20Dennis Kleind.klein@gsi.deDennis Kleind.klein@gsi.dehttps://git.gsi.de/SDE/cxx-user-group/-/issues/2SFINAE, enable_if, and an outlook to Concepts2024-02-21T16:26:48ZMatthias KretzSFINAE, enable_if, and an outlook to ConceptsC++ has an important feature called “Substitution Failure Is Not An Error”. Meaning, if implicit template argument substitution leads to an error, the expression is simply ignored and the error never becomes visible to the user. With thi...C++ has an important feature called “Substitution Failure Is Not An Error”. Meaning, if implicit template argument substitution leads to an error, the expression is simply ignored and the error never becomes visible to the user. With this it is then possible to have very fine-grained control over overload resolution.
C++20 has a much nicer syntax for this task with additional semantics, called concepts, changing the way we define generic interfaces. This talk will give a brief outlook to C++20's concepts feature.Matthias KretzMatthias Kretz2024-02-21https://git.gsi.de/SDE/cxx-user-group/-/issues/6std::unique_ptr introduction2021-09-23T07:41:26ZMatthias Kretzstd::unique_ptr introductionMeeting 21-38Dennis Kleind.klein@gsi.deDennis Kleind.klein@gsi.dehttps://git.gsi.de/SDE/cxx-user-group/-/issues/12argument-dependent lookup (ADL) and hidden friends2022-04-06T22:10:42ZMatthias Kretzargument-dependent lookup (ADL) and hidden friendsMeeting 22-14Matthias KretzMatthias Kretzhttps://git.gsi.de/SDE/cxx-user-group/-/issues/13type punning / strict aliasing / proper casts2022-07-21T06:22:49ZMatthias Kretztype punning / strict aliasing / proper casts* C casts
* `reinterpret_cast`
* `std::memcpy`
* [`std::bit_cast`](https://en.cppreference.com/w/cpp/numeric/bit_cast)
* [start_lifetime_as](https://wg21.link/p0593)
* aliasing rules* C casts
* `reinterpret_cast`
* `std::memcpy`
* [`std::bit_cast`](https://en.cppreference.com/w/cpp/numeric/bit_cast)
* [start_lifetime_as](https://wg21.link/p0593)
* aliasing rulesMeeting 22-29m.alfonsim.alfonsihttps://git.gsi.de/SDE/cxx-user-group/-/issues/17Q: detecting class deriving from template (w/ types & NTTPs) including std types2021-07-26T15:26:33ZRalph J. SteinhagenQ: detecting class deriving from template (w/ types & NTTPs) including std typesThis is my first post here in the hope that somebody knowledgeable can-do-expert may be able to advise.
And also: please forgive me because I am about to sin ... (ie. 'thou shall not derive from standard types') :smirk:
A bit of pre-c...This is my first post here in the hope that somebody knowledgeable can-do-expert may be able to advise.
And also: please forgive me because I am about to sin ... (ie. 'thou shall not derive from standard types') :smirk:
A bit of pre-context: We are re-designing/implementing/improving a [new middle-ware](https://github.com/fair-acc/opencmw-cpp) to aid us and other accelerator-domain experts at FAIR in their beam-based feedback and signal processing applications. As one of its core functionalities, it implements a domain-object driven serialisation scheme that heavily relies on C++20 concepts, [refl-cpp](https://github.com/veselink1/refl-cpp) as pre-cursor to compile-time/static reflection, and [mp-units](https://github.com/mpusz/units) to support type- and notable physical-unit safety in our code/algorithms and to enhance the overall end-user development experience. Both of the latter libraries/functionalities are targeted to become part of the C++ standard.
At its core, the user defines domain-objects (e.g. measurement data object/structs or control data) that contain plain and annotated C++ data types -- notably without having to rely on an IDL description -- that are passed, shared and combined within a distributed micro-service topology (N.B. 'distributed' because these devices are physically distributed across and very close to our accelerators). As an example:
```cpp
struct DomainObject {
si::speed<metre_per_second> speedValue = valUnit;
double doubleValue = 42.0;
std::array<double, 3> doubleArray = { 1., 2., 3.};
Annotate<float, speed<metre_per_second>, "custom description"> annotatedSpeed = quantity_cast<si::speed<si::metre_per_second, float>>(valUnit);
Annotate<float, length<metre>, "this length is ..."> annotatedLength;
Annotate<double, si::time<second>, "time as measured ... "> annotatedTime;
Annotate<short, energy<electronvolt>, "energy of ..."> annotatedEnergy;
Annotate<std::string, NoUnit, "string documentation"> annotatedString = "Hello World!";
Annotate<CustomUserStruct, NoUnit, "user-defined object1"> customStruct = CustomUserStruct{1.1, 2.2, 3.3};
Annotate<std::array<int, 3>, NoUnit, "user-defined array"> annotatedArray = { 10, 20, 30};
DomainObject() : annotatedSpeed(10.0_q_km_per_h), annotatedLength(100.0_q_m), annotatedTime(9.8_q_s){};
};
```
A more complete mock-up example can be explored using the [compiler-explorer](https://compiler-explorer.com/z/T6vP8xedf).
While the serialisation and compile-time reflections work without, we wrote a transparent `Annotated<..>` wrapper interfaces
```cpp
// Annotate using mp-unit's quantity and operator inheritance, unit- and type-safety checks
template <units::Representation Rep, units::Quantity Q, const units::basic_fixed_string description>
struct Annotate<Rep, Q, description> : public units::quantity<typename Q::dimension, typename Q::unit, Rep> {
// [..]
// needed for API description/compile-time serialisation
[[nodiscard]] constexpr const String getUnit() const noexcept { return String(units::detail::unit_text<dimension, unit>().ascii().c_str()); }
[[nodiscard]] constexpr const String getDescription() const noexcept { return description.c_str(); }
[[nodiscard]] constexpr const String getTypeName() const noexcept { return typeName<Rep>(); }
//[..]
};
```
and
```cpp
// Annotate using mp-unit's quantity/unit info (only) w/o unit- and type-safety checks
template <ClassType T, typename Q, const units::basic_fixed_string description>
struct Annotate<T, Q, description> : T { // inherit from T directly to inherit also all its potential operators & member functions
// [..]
};
```
as part of this scheme that allows attaching additional (but optional) meta-information to instruct the compile-time serialiser and other general behaviours, for example: whether the data is read-only (w.r.t. remote-IO but still modifiable internally); whether it is optional/individually settable, or needs to be set within a given set of other fields, etc.). For the server-side processing, this does not provide any relevant (hidden) state and the wrapper is thus designed to be as transparent as possible and to -- importantly -- pass-through any operator or member functions of the container or user-supplied struct.
While this works fine for polymorphic types (notably those used by the mp-units library, first template specialisation), I am having some small troubles with deriving from std containers. While this scheme works fine for the serialisation and general processing, there is a noticable difference w.r.t. detecting the base template the `Annotate<>` specialisation is derived from. In the example code this is demonstrated at the end:
```cpp
std::cout << std::boolalpha;
std::cout << "speedValue is an array or vector: " << is_array_or_vector<decltype(data.speedValue)> << std::endl; // OK
std::cout << "doubleArray is an array or vector: " << is_array_or_vector<decltype(data.doubleArray)> << std::endl; // OK
std::cout << "annotatedArray is an array or vector: " << is_array_or_vector<decltype(data.annotatedArray)> << std::endl; // not OK
std::cout << "annotatedArray is an array or vector: " << is_array_or_vector<decltype(data.annotatedArray.rawValue())> << std::endl; // alt1: not OK
std::cout << "annotatedArray is an array or vector: " << units::is_derived_from_specialization_of<decltype(data.annotatedArray), std::vector> << std::endl; // alt2: not OK
// std::cout << "val8 is an array or vector: " << std::is_base_of<std::array, decltype(data.val8)>::value << std::endl; // not work because being a template & with NTTPs :-|
data.annotatedArray[2] = 42; // OK -- works as designed
std::cout << "annotatedArray content: " << data.annotatedArray << std::endl; // OK -- works as designed
std::cout << "doubleArray content: " << data.doubleArray << std::endl; // OK -- works as designed
//std::cout << "annotatedArray content: " << data.annotatedArray << std::endl; // not OK
std::cout << "annotatedArray content: " << data.annotatedArray.rawValue() << std::endl; // work-around OK but ugly from a users perspective
```
While the basic functionalities do work -- on the meta-programming level I am having trouble to differentiate or better to not differentiate between, e.g. an 'std::array' and something that derives from it. Part of the issue seems to be that most trait functions rely on `template<typename... Params, template<typename...> typename Type>` of some sorts but the templates I am having trouble with also contains NTTPs (ie. something that is not caught by `typename ...`)
I hope the practical solution to this is obvious to someone or an hardcore C++20 fan. Any constructive help would be much appreciated
The full example, also at [compiler-explorer](https://compiler-explorer.com/z/T6vP8xedf):
<details>
```cpp
// ############# library code mock-up ################ -- user code see below
#include <units/concepts.h>
#include <units/quantity.h>
#include <units/quantity_io.h>
#include <iostream>
#include <string>
// extract of concept definitions
template<typename T>
inline constexpr bool is_array_or_vector = false;
template<typename T, typename A>
inline constexpr bool is_array_or_vector<std::vector<T, A>> = true;
template<typename T, typename A>
inline constexpr bool is_array_or_vector<const std::vector<T, A>> = true;
template<typename T, std::size_t N>
inline constexpr bool is_array_or_vector<std::array<T, N>> = true;
template<typename T, std::size_t N>
inline constexpr bool is_array_or_vector<const std::array<T, N>> = true;
template<typename T>
concept ArrayOrVector = is_array_or_vector<T>;
// N.B. extend this for custom classes using type-traits to query nicer class-type name
template <typename T, typename Tp = typename std::remove_const<T>::type>
requires (!is_array_or_vector<Tp>)
constexpr const char* typeName() noexcept {
if (std::is_same<Tp, std::byte>::value) { return "byte"; }
if (std::is_same<Tp, char>::value) { return "char"; }
if (std::is_same<Tp, short>::value) { return "short"; }
if (std::is_same<Tp, int>::value) { return "int"; }
if (std::is_same<Tp, long>::value) { return "long"; }
if (std::is_same<Tp, float>::value) { return "float"; }
if (std::is_same<Tp, double>::value) { return "double"; }
if (units::is_derived_from_specialization_of<Tp, std::basic_string>) { return "string"; }
return typeid(T).name();
}
template<ArrayOrVector T>
constexpr const char* typeName() noexcept {
return "it's an std::array or std::vector";
}
template <typename T>
concept ClassType = std::is_class<T>::value;
using NoUnit = units::dimensionless<units::one>;
template <typename Rep, typename Q = units::dimensionless<units::one>, const units::basic_fixed_string description = "" /*, more user-specific NTTPs */>
struct Annotate; // prototype template -- N.B. there are two implementations since most non-numeric classes do not qualify as units::Representation
// Annotate using mp-unit's quantity and operator inheritance, unit- and type-safety checks
template <units::Representation Rep, units::Quantity Q, const units::basic_fixed_string description>
struct Annotate<Rep, Q, description> : public units::quantity<typename Q::dimension, typename Q::unit, Rep> {
using dimension = typename Q::dimension;
using unit = typename Q::unit;
using rep = Rep;
using R = units::quantity<dimension, unit, Rep>;
using String = std::string_view;
constexpr Annotate() : R(){};
constexpr explicit(!std::is_trivial_v<Rep>) Annotate(const R& t) : R(t) {}
constexpr explicit(!std::is_trivial_v<Rep>) Annotate(R&& t) : R(std::move(t)) {}
constexpr Annotate& operator=(const R& t) { R::operator=(t); return *this; }
constexpr Annotate& operator=(R&& t) { R::operator=(std::move(t)); return *this; }
// needed for API description/compile-time serialisation
[[nodiscard]] constexpr const String getUnit() const noexcept { return String(units::detail::unit_text<dimension, unit>().ascii().c_str()); }
[[nodiscard]] constexpr const String getDescription() const noexcept { return description.c_str(); }
[[nodiscard]] constexpr const String getTypeName() const noexcept { return typeName<Rep>(); }
// [..]
// raw data access
[[nodiscard]] constexpr inline rep& rawValue() & noexcept { return this->number(); }
[[nodiscard]] constexpr inline const rep& rawValue() const & noexcept { return this->number(); }
[[nodiscard]] constexpr inline rep&& rawValue() && noexcept { return std::move(this->number()); }
[[nodiscard]] constexpr inline const rep&& rawValue() const && noexcept { return std::move(this->number()); }
};
// Annotate using mp-unit's quantity/unit info (only) w/o unit- and type-safety checks
template <ClassType T, typename Q, const units::basic_fixed_string description>
struct Annotate<T, Q, description> : T { // inherit from T directly to inherit also all its potential operators & member functions
using dimension = typename Q::dimension;
using unit = typename Q::unit;
using rep = T;
using String = std::string_view;
constexpr Annotate() : T() {}
explicit(!std::is_trivial_v<T>) constexpr Annotate(const T& t) : T(t) {}
explicit(!std::is_trivial_v<T>) constexpr Annotate(T&& t) : T(std::move(t)) {}
template <class... S>
Annotate(S&&... v) : T{std::forward<S>(v)...} {}
template <class S, std::enable_if_t<std::is_constructible<T, std::initializer_list<S>>::value, int> = 0>
Annotate(std::initializer_list<S> init) : T(init) {}
template <typename U>
requires(std::is_assignable<T, U>::value) Annotate(const U& u) : T(u) {}
template <typename U>
requires(std::is_assignable<T, U>::value) Annotate(U&& u) : T(std::move(u)) {}
// needed for API description/compile-time serialisation
[[nodiscard]] constexpr const String getUnit() const noexcept { return String(units::detail::unit_text<dimension, unit>().ascii().c_str()); }
[[nodiscard]] constexpr const String getDescription() const noexcept { return description.c_str(); }
[[nodiscard]] constexpr const String getTypeName() const noexcept { return typeName<T>(); }
// [..]
// raw data access
[[nodiscard]] constexpr inline T& rawValue() & noexcept { return *this; }
[[nodiscard]] constexpr inline const T& rawValue() const & noexcept { return *this; }
[[nodiscard]] constexpr inline T&& rawValue() && noexcept { return std::move(*this); }
[[nodiscard]] constexpr inline const T&& rawValue() const && noexcept { return std::move(*this); }
};
// nicer print-out for arrays and vectors
template<ArrayOrVector T>
std::ostream &operator<<(std::ostream &os, const T &v) {
using ValueType = typename T::value_type;
os << '{';
std::copy(std::begin(v), std::end(v), std::ostream_iterator<ValueType>(os,", "));
os << "}";
return os;
}
int counter = 0; // just for debugging
template <typename T>
constexpr void printMetaInfo(const T& value) {
if constexpr (requires { value.getTypeName(); }) { // simplistic 'Annotate' detection
std::cout << "AN-value" << counter++ << ": '" << value.rawValue() << "' type: '" << value.getTypeName() << "' unit: '" << value.getUnit() << "' description: '" << value.getDescription() << "'\n";
} else { // not annotated variable
std::cout << "NA-value" << counter++ << ": '" << value << "' type: '" << typeName<decltype(value)>() << "'\n";
}
}
// ########################################
// ############# user code ################
// ########################################
#include <units/isq/si/length.h>
#include <units/isq/si/speed.h>
#include <units/isq/si/energy.h>
struct CustomUserStruct {
double x = 1;
double y = 2;
double z = 3;
};
// N.B. 'operator<<' replaced by generic compile-time reflection
std::ostream& operator<<(std::ostream& os, const CustomUserStruct& m) noexcept {
return os << "{x:" << m.x << ", y: " << m.y << ", z: " << m.z << '}';
}
using namespace units::isq;
using namespace units::isq::si;
using namespace std::literals;
constexpr Speed auto valUnit = 110._q_km_per_h;
struct DomainObject {
si::speed<metre_per_second> speedValue = valUnit;
double doubleValue = 42.0;
std::array<double, 3> doubleArray = { 1., 2., 3.};
Annotate<float, speed<metre_per_second>, "custom description"> annotatedSpeed = quantity_cast<si::speed<si::metre_per_second, float>>(valUnit);
Annotate<float, length<metre>, "this length is ..."> annotatedLength;
Annotate<double, si::time<second>, "time as measured ... "> annotatedTime;
Annotate<short, energy<electronvolt>, "energy of ..."> annotatedEnergy;
Annotate<std::string, NoUnit, "string documentation"> annotatedString = "Hello World!";
Annotate<CustomUserStruct, NoUnit, "user-defined object1"> customStruct = CustomUserStruct{1.1, 2.2, 3.3};
Annotate<std::array<int, 3>, NoUnit, "user-defined array"> annotatedArray = { 10, 20, 30};
DomainObject() : annotatedSpeed(10.0_q_km_per_h), annotatedLength(100.0_q_m), annotatedTime(9.8_q_s){};
};
constexpr Speed auto avg_speed(Length auto d, Time auto t) { return d / t; }
int main() {
DomainObject data;
// N.B. loop replaced with compile-time reflection
printMetaInfo(data.speedValue);
printMetaInfo(data.doubleValue);
printMetaInfo(data.doubleArray);
printMetaInfo(data.annotatedSpeed);
printMetaInfo(data.annotatedLength);
printMetaInfo(data.annotatedTime);
printMetaInfo(data.annotatedEnergy);
printMetaInfo(data.annotatedString);
printMetaInfo(data.customStruct);
printMetaInfo(data.annotatedArray);
Speed auto fastRunnerVelocity = avg_speed(data.annotatedLength, data.annotatedTime);
std::cout << "a fast athlete can run: " << fastRunnerVelocity << "\n\n";
Speed auto ok1 = fastRunnerVelocity + 10_q_m_per_s;
Speed auto ok2 = fastRunnerVelocity*0.5;
//Speed auto error = fastRunnerVelocity + 10; // causes (correct) compile-time error for missing/mismatched unit
data.annotatedSpeed.number() = data.annotatedSpeed.number() + 20; // N.B. raw-access needed for raw serialiser read/write access - OK
std::cout << std::boolalpha;
std::cout << "speedValue is an array or vector: " << is_array_or_vector<decltype(data.speedValue)> << std::endl; // OK
std::cout << "doubleArray is an array or vector: " << is_array_or_vector<decltype(data.doubleArray)> << std::endl; // OK
std::cout << "annotatedArray is an array or vector: " << is_array_or_vector<decltype(data.annotatedArray)> << std::endl; // not OK
std::cout << "annotatedArray is an array or vector: " << is_array_or_vector<decltype(data.annotatedArray.rawValue())> << std::endl; // alt1: not OK
std::cout << "annotatedArray is an array or vector: " << units::is_derived_from_specialization_of<decltype(data.annotatedArray), std::vector> << std::endl; // alt2: not OK
// std::cout << "val8 is an array or vector: " << std::is_base_of<std::array, decltype(data.val8)>::value << std::endl; // not work because being a template & with NTTPs :-|
data.annotatedArray[2] = 42; // OK -- works as designed
std::cout << "doubleArray content: " << data.doubleArray << std::endl; // OK -- works as designed
//std::cout << "annotatedArray content: " << data.annotatedArray << std::endl; // not OK
std::cout << "annotatedArray content: " << data.annotatedArray.rawValue() << std::endl; // work-around OK but ugly from a users perspective
return data.annotatedArray[2];
}
```
</details>https://git.gsi.de/SDE/cxx-user-group/-/issues/19Static Analysis Part I: `clang-tidy` and `clangd`2022-01-26T16:17:32ZDennis Kleind.klein@gsi.deStatic Analysis Part I: `clang-tidy` and `clangd`* Usage
* Integration with CMake
* Integration with IDE (LSP)
* How does it work?
* Examples* Usage
* Integration with CMake
* Integration with IDE (LSP)
* How does it work?
* ExamplesMeeting 22-04Dennis Kleind.klein@gsi.deDennis Kleind.klein@gsi.dehttps://git.gsi.de/SDE/cxx-user-group/-/issues/23Modern CMake2022-03-21T14:30:10ZDennis Kleind.klein@gsi.deModern CMakeMeeting 21-44Dennis Kleind.klein@gsi.deDennis Kleind.klein@gsi.dehttps://git.gsi.de/SDE/cxx-user-group/-/issues/25const-correctness in C++2021-11-17T16:51:10ZMatthias Kretzconst-correctness in C++Meeting 21-46Matthias KretzMatthias Kretzhttps://git.gsi.de/SDE/cxx-user-group/-/issues/26Constexpr, Strict type-checking & mp-units2021-12-14T10:42:14ZMatthias KretzConstexpr, Strict type-checking & mp-unitsMeeting 21-48Ralph J. SteinhagenRalph J. Steinhagenhttps://git.gsi.de/SDE/cxx-user-group/-/issues/27an overview of literals2022-01-12T19:52:25ZMatthias Kretzan overview of literals* character literals
* string literals
* integer literals (decimal, octal, hexadecimal or binary)
* floating-point literals (float, double, or long double)
* digit separators
* boolean literals
* nullptr
* user-defined literals* character literals
* string literals
* integer literals (decimal, octal, hexadecimal or binary)
* floating-point literals (float, double, or long double)
* digit separators
* boolean literals
* nullptr
* user-defined literalsMeeting 22-02Matthias KretzMatthias Kretzhttps://git.gsi.de/SDE/cxx-user-group/-/issues/29my work: simd research, libstdc++ and GCC development, C++ committee2022-02-09T15:59:10ZMatthias Kretzmy work: simd research, libstdc++ and GCC development, C++ committeeMeeting 22-06Matthias KretzMatthias Kretzhttps://git.gsi.de/SDE/cxx-user-group/-/issues/31Buildsystems Demystified2022-03-29T18:39:59ZChristian TackeBuildsystems DemystifiedIn #23 we looked at modern CMake.
Sometimes it feels like (meta) build systems / generators like CMake do a lot of magic and you need to study five years of rocket science to know what these things really do.
This live demo tries to sh...In #23 we looked at modern CMake.
Sometimes it feels like (meta) build systems / generators like CMake do a lot of magic and you need to study five years of rocket science to know what these things really do.
This live demo tries to show the most important ingrediensts of C++ projects being built using CMake from the ground up:
* Call the compiler manually
* Automate using script
* Automate using simple Makefile
* Add some bells and whistles
* Add dependencies
* automate dependency tracking
* Be mostly happy!
* Rewrite using CMakeMeeting 22-12Christian TackeChristian Tackehttps://git.gsi.de/SDE/cxx-user-group/-/issues/30distributed real-time programming & event-sourcing pattern2022-03-29T18:41:57ZMatthias Kretzdistributed real-time programming & event-sourcing patternMeeting 22-10Ralph J. SteinhagenRalph J. Steinhagenhttps://git.gsi.de/SDE/cxx-user-group/-/issues/32stdx::simd — generic data-parallelism via type-based vectorization2023-03-09T08:04:29ZMatthias Kretzstdx::simd — generic data-parallelism via type-based vectorizationMeeting 23-08Matthias KretzMatthias Kretzhttps://git.gsi.de/SDE/cxx-user-group/-/issues/33Open Common-Middleware – OpenCMW2022-07-10T09:51:20ZMatthias KretzOpen Common-Middleware – OpenCMWMeeting 22-24Ralph J. SteinhagenRalph J. Steinhagenhttps://git.gsi.de/SDE/cxx-user-group/-/issues/34Yet-Another-Serialiser (YAS)2023-02-09T08:55:01ZRalph J. SteinhagenYet-Another-Serialiser (YAS)### or: why we are not reusing and opted to write yet another custom data serialiser
* Serialisation is key when information has to be transmitted, stored and later retrieved by (often quite) different subsystems, architectures and/or p...### or: why we are not reusing and opted to write yet another custom data serialiser
* Serialisation is key when information has to be transmitted, stored and later retrieved by (often quite) different subsystems, architectures and/or programming languages.
with a multitude of different serialiser libraries, a non-negligible subset of these claim to be the fastest, most efficient, easiest-to-use or <add your favourite superlative here>
this is true for most libraries' original use-case but often breaks down for other applications.
* This talk aims at motivating our compile-time reflection based approach used in OpenCMW
[supporting slides](/uploads/5fbe8245d5c4100e5ed0a1cb2d789464/20221012_Cpp_UG_Meeting_Serialiser.pdf)
[supporting slides (expanded)](/uploads/114531b93342bab164635a6c5edc6494/20221012_Cpp_UG_Meeting_Serialiser-expanded.pdf)
[supporting slides (sources)](/uploads/4efb5dcd59f2266a3855f258a6f8a762/20221012_Cpp_UG_Meeting_Serialiser.odp)Meeting 22-41Ralph J. SteinhagenRalph J. Steinhagenhttps://git.gsi.de/SDE/cxx-user-group/-/issues/36Data analysis with ROOT RDataFrame: what I like and what I would like2022-11-17T08:20:48ZMatthias KretzData analysis with ROOT RDataFrame: what I like and what I would likeMeeting 22-45m.alfonsim.alfonsihttps://git.gsi.de/SDE/cxx-user-group/-/issues/37C++ committee meeting Kona '22 - trip report2022-11-24T06:39:40ZMatthias KretzC++ committee meeting Kona '22 - trip reportMeeting 22-47Matthias KretzMatthias Kretzhttps://git.gsi.de/SDE/cxx-user-group/-/issues/38WebAssembly: compiling C++ for the web and more2022-11-30T15:41:47Za.krimmWebAssembly: compiling C++ for the web and more- What is Webassembly?
- overview
- differences to traditional c++ programs
- How can C++ be used for applications in the web browser
- compatible UI frameworks: Qt, SDL, imgui
- toolchains and build support
- emcc, emmake, emcmake...- What is Webassembly?
- overview
- differences to traditional c++ programs
- How can C++ be used for applications in the web browser
- compatible UI frameworks: Qt, SDL, imgui
- toolchains and build support
- emcc, emmake, emcmake, toolchain file
- special compiler flags
- limitations
- special solutions
- support wasm and native targets from the same codebase
- embed webassembly artifacts into native server applications using cmake, externalProject and cmakeRC
- running webassembly outside of the webbrowser: node, wasmtimeMeeting 22-48a.krimma.krimm2022-11-30https://git.gsi.de/SDE/cxx-user-group/-/issues/39Discussion: Effective Usage of Version Control Commits2023-02-09T08:32:44ZDennis Kleind.klein@gsi.deDiscussion: Effective Usage of Version Control CommitsMeeting 23-06https://git.gsi.de/SDE/cxx-user-group/-/issues/40Conway's Law: "The Only Unbreakable Law" Lecture by Casey Muratori2023-10-29T07:38:36ZRalph J. SteinhagenConway's Law: "The Only Unbreakable Law" Lecture by Casey MuratoriWe wanted to try a novel format to dive into a fascinating topic: Conway’s Law.
This [YouTube Lecture](https://youtu.be/5IUj1EZwpJY) delves into Conway’s Law, exploring the relationship between an organisation's communication structures...We wanted to try a novel format to dive into a fascinating topic: Conway’s Law.
This [YouTube Lecture](https://youtu.be/5IUj1EZwpJY) delves into Conway’s Law, exploring the relationship between an organisation's communication structures and the architectural designs they produce. Muratori shows how cognitive constraints and modern technological advancements shape design efficiency through compelling examples and insights.
Conway, Melvin E.: “How Do Committees Invent?”. In: Datamation (1968) [original paper](/uploads/ba3fa2eddd700e7b50e89564c6ec0f70/Conway__Melvin_E.__How_Do_Committees_Invent_._In__Datamation__1968_.pdf)Ralph J. SteinhagenRalph J. Steinhagen2023-06-14