C++ Middleware Writer VS cppfront

I use unique_ptr, but not as much as I used to. I've never used shared_ptr. This is my library that uses some C++ 2020 and 2017 features.

I started with Linux in the late 90s. I switched to FreeBSD around 2013 and returned to Linux a couple of years ago. Io_uring was the main reason I had to come back. At first I ported the back tier of my code generator back to Linux and then I ported the middle tier from being POSIX based to Linux.

Are there others that minimize multithreading and opt for multi-processing with single threaded processes? Call me a simpleton, but this approach eliminates some of the most difficult bugs by design. Here's an example of one of my single-threaded servers. The network io is asynchronous, but the file io is synchronous. Thanks

I've been working on this program for 13 years now. At one point it had 7 global variables and none of them were const. Now it has 4 global variables and 2 of them are const.

in one of my programs. I'm thinking about changing it to:

It's a merger of services and code generation: an on-line code generator that outputs low-level messaging and serialization code based on high-level input. It's implemented as a 3-tier system and uses output from the code generator in each tier. There's also a traditional library that's part of the repo.

Support for more data types for message lengths. Previously message lengths were always 4 bytes. I used this, for example, to reduce the size of the type used for message lengths between the front and middle tiers of the CMW from 4 bytes to 2 bytes.

More concretely, I use it to generate code that's used in each of the tiers mentioned above. The link is to one example of that.

In this article, we will explore how CppFront aims to make C++ a better place by introducing a new syntax, improving safety and usability and providing modern features that align with good programming practices - all while maintaining full interoperability with C++.

> And I'm left wondering, is this just how C++ is? Can't the language provide tooling for me to better adhere to its guidelines

Well, first, the language can't provide tooling: C++ is defined formally, not through tools; and tools are not part of the standard. This is unlike, say, Rust, where IIANM - so far, Rust has been what the Rust compiler accepts.

But it's not just that. C++ design principles/goals include:

* multi-paradigmatism;

* good backwards compatibility;

* "don't pay for what you don't use"

and all of these in combination prevent baking in almost anything: It will either break existing code; or force you to program a certain way, while legitimate alternatives exist; or have some overhead, which you may not want to pay necessarily.

And yet - there are attempts to "square the circle". An example is Herb Sutter's initiative, cppfront, whose approach is to take in an arguably nicer/better/easier/safer syntax, and transpile it into C++ :

https://github.com/hsutter/cppfront/

I’m not fond of adding an increasing number of specific compiler options for memory-safety. I love -faddress=sanitizer or -fsanitize. But the historically growing number of warning which need to be turned on is an issue. For example the options -Wconversion, -Wsign-conversion and -Warith-conversion shall be default with C++26. And if your code doesn’t compile use either an older revision or turn it deliberately off (saying: I’m aware, read the handbook, I take the risk).

I want some of not all the ideas of CPP2/cppfront[1] in C++XX. Finally using #unsafe when needed, like Rust. C++ does evolve over decades, more like other languages.

[1] https://github.com/hsutter/cppfront

CPP2/cppfront:

https://github.com/hsutter/cppfront

I hope we see this in C++26 as optional mode i.e. #safe and #unsafe and same for #impdef or so.

C++23 is done. But C++ is not! In this talk, the author shares his personal perspectives on an ongoing and very active evolution of C++, updates on his cppfront experimental compiler, and why compatibility is essential to the further success of the C++ development.

https://github.com/hsutter/cppfront

But his side project at Microsoft didn't gain traction with gcc, clang, etc and everybody else in the industry. So at this point, the C++ committee will be perceived as "so far behind" ... because there's nothing for them to vote on.