sentry-native VS score-simple-api-2

I understand what C bindings means - hence my comment about the lowest common denominator. I'm not deeply familiar with the Lua api so I don't feel comfortable commenting on it, but the sentry C api is a prime example. Yes you can use this API from many different languages, including C++, but you end up writing code like this. You almost always lose type safety, RAII, and introduce error prone, verbose code, such as: sentry_value_t debug_crumb = sentry_value_new_breadcrumb("http", "debug crumb"); sentry_value_set_by_key( debug_crumb, "category", sentry_value_new_string("example!")); sentry_value_set_by_key( debug_crumb, "depth", sentry_value_new_int32(11)); sentry_value_set_by_key( debug_crumb, "level", sentry_value_new_string("debug")); sentry_add_breadcrumb(debug_crumb);

> Put another way, I'd rather fix relatively simple C (which also tends to be simpler code in general) than the monsters created by "modern C++" because they thought the "added safety" would mean they could go crazy with the complexity without adding bugs.

It's completely possible to write C++ code without it being a mess of a template mostrosity and massively overloaded function names. People who write C++ like that would write C filled with macros, void pointers and all the other footguns that C encourages you to use instead.

I've been working with the sentry-native SDK recently [0] which is a C api. It's full of macros, unclear ownership of pointers (in their callback, _you_ must manually free the random pointer, using the right free method for their type, which isn't type checked), custom functions for working with their types (sentry_free, sentry_free_envelope), opaque data types (everythign is a sentry_value_t created by a custom function - to access the data you have to call the right function not just access the member, and this is a runtime check).

Compare [1] (their C api example)

[0] https://github.com/getsentry/sentry-native

You can also write things in a way that the user only has to provide things in a declarative way.

For instance I'm working on an API for defining dataflow nodes for multimedia applications which tries to leave zero margin for error : the user simply has to define the inputs and outputs like this, as types, which the C++ type machinery is able to digest :

https://github.com/jcelerier/score-simple-api-2/blob/main/Si...

In contrast, in C, one has to cast things left and right because the only tool you have is void* : see for instance

https://cycling74.com/sdk/max-sdk-7.3.3/html/chapter_msgatta...

or

https://cycling74.com/sdk/max-sdk-7.3.3/html/chapter_msp_adv...

in both cases we are defining a dynamic dataflow node with various inputs / outputs (for instance an audio input and output, plus a control), which is then displayed in an user interface (thus things have to be reflected in some way).