geteilt von: https://programming.dev/post/50633812

Hello everyone

We released iceoryx2 v0.9 tonight. With the release, we are pushing more and more iceoryx2 into the embedded world. We have written a test runner that runs on std and no_std environments, stabilized the decentralized recovery, and added a ton of quality of life improvements.

• blog article: https://ekxide.io/blog/iceoryx2-0.9-release
• repo: https://github.com/eclipse-iceoryx/iceoryx2
• roadmap: https://github.com/eclipse-iceoryx/iceoryx2/blob/main/ROADMAP.md
• crates-io: https://crates.io/crates/iceoryx2
• docs-rs: https://docs.rs/iceoryx2/latest/iceoryx2

For those who haven’t heard of it yet: iceoryx2 is a zero-copy inter-process communication library.

The basic idea is: instead of serializing data, copying it through sockets, pipes, message queues, or some broker process, iceoryx2 lets processes communicate via shared memory. That makes it useful when you care about latency, throughput, or moving large amounts of data between processes without wasting CPU cycles on copies.

It supports C, C++, Python, Rust, and C#, and runs on Linux, macOS, Windows, FreeBSD, and QNX, with experimental support for Android and VxWorks.

It is not limited to plain pub/sub either. iceoryx2 supports publish-subscribe, events, request-response streams, and a blackboard pattern, which is basically a key-value repository directly in shared memory.

The architecture is fully decentralized: no central broker, no daemon that everything depends on, and no single process that becomes the obvious bottleneck or failure point.

Happy to answer questions about the release, the no_std work, or zero-copy IPC in general.

PVS-Studio devs are continuing the series of talks on building a custom C++ based programming language.

In this session, the speaker will explain what a parser is, walk through the recursive descent approach, and show how to build your own expression parser from scratch.

Join the talk here.

C++20 coroutines have lovely syntax. They are also a terrible fit for game development. In this article, the author will present sfex::Coroutine: a ~200-line stackless macro-based coroutine library built around a variant of the classic switch + LINE trick.

Please share your feedback in this annual 10-minute survey to help inform C++ standardization and C++ tool vendors. This is the biggest opportunity we all have each year to make our voices heard and help improve our industry and community!

A summary of the results, including aggregated highlights of common answers in the write-in responses, will be posted publicly here on isocpp.org and shared with the C++ standardization committee participants and C++ tool vendors to help inform C++ evolution and tooling.

The survey closes in one week.

Thank you for participating and helping to inform our committee and community.

cross-posted from: https://programming.dev/post/48958963

PVS-Studio devs are continuing their series of talks about creating a custom C++ based programming language.

This time, the speaker will explain what the lexer is, what it consists of, and how to work with it.

If you want to join, follow the link!

So i am basically almost done with my C++ App Logic Wise tho the only thing i struggle with and wanna figure it is how to include a seperate class into my main class constructors >.>

Mostly due to the fact that currently in my Code my main Code has 2 Objects tho ErrorWin Object is right now the only one that exist twice as seperate Objects which itd like to fix >.>

So this is my first Object in my Main Function which just calls my DisplayWindow Function while my ErrorWin Object calls the Display Error Window Function :P

int main() {
  ErrorWindow ErrorWin;
  MainWindow MainWin;

  if (ProgramPath.empty()) {
    ErrorWin.DisplayErrorWindow();
    return Fl::run();
  }

  MainWin.DisplayMainWindow();
  return Fl::run();
}

Now the Main Issue is that only my First Text basically gets displayed in the Error Window even tho my switch Statement is set to display a different error text basically according to my callback but that obviously does not work due to theyre being seperate ErrorWin Objects :(

void MainWindow::CallbackSaveFile(Fl_Widget* Widget, void* Data) {
  MainWindow* MainWindowData = static_cast<MainWindow*>(Data);
  ErrorWindow ErrorWin;

  if (!MainWindowData->InputFile.empty()) {
    ...
  } else {
    ErrorWin.DisplayErrorWindow();
  }
}

On Saturday, the ISO C++ committee completed technical work on C++26 in (partly) sunny London Croydon, UK. We resolved the remaining international comments on the C++26 draft, and are now producing the final document to be sent out for its international approval ballot (Draft International Standard, or DIS) and final editorial work, to be published in the near future by ISO.

The 6.11 release for Qt Framework is now available, with improved performance, newly supported techniques and capabilities on graphics, connectivity and languages, not to mention a whole new approach to asynchronous C++ coding.

• Hardware-Accelerated 2D Rendering: A new module, Qt Canvas Painter, based on the HTML Canvas 2D Context, provides performance & productivity gains.
• 3D Improvements: New rendering techniques Screen Space Global Illumination (SSGI) as an option for lightmap baking, and Screen Space Reflections (SSR). Also imrovements on the Temporal Anti-aliasing algorithm with motion vectors. New user-defined render passes for post-processing effects, color picking, layer masks, etc. directly in QML.
• Interactive Graphs: You can now implement custom graphs where a user-defined delegate renders each data point. There's a new Qt example, the Wind Turbine Dashboard, and many improvements, e.g. new ways to style line graphs, and multi-axis support on 3D graphs.
• Declarative Approach to C++: Qt Task Tree brings a whole new approach to asynchronous coding and C++ API design in Qt. In addition, various APIs have been unified to allow adapting any asynchronous task to work with the new module.
• Other Improvements: Improvements on vector graphics, controls, and accessibility. Connecting to web servicers is now easier with the new module, Qt OpenAPI. Navigating in an IDE between QML and C++, and making data available from C++ backend code to Qt Quick have gotten easier. A wealth of other improvements, such as for multimedia, Android, and API documentation.

Any std::valarray users represent?

PVS-Studio presents a series of webinars on how to build your own programming language in C++. In the first session, we will go over what’s inside the “black box”. In clear and plain terms, they’ll explain what a lexer, parser, a semantic analyzer, and an evaluator are.

Yuri Minaev, C++ architect at PVS-Studio, will talk about what these components are, why they’re needed, and how they work. Welcome to join.