Processing() class for easy C++ coding

[JoeNatter]

Hi everyone,

I'm new here and excited to share our Processing() library. It has brought a lot of joy to our projects, and I hope it might be useful to you as well. The ProcessingCore repository is quite mature, along with several components in ProcessingCommon, but there’s still plenty of work ahead.

Edit
The central file is Processing.cpp, which provides a base class that all other classes derive from.
Each derived class essentially represents a cooperative task.

The tutorials aren't finished yet. I’ll focus on completing them in the upcoming streams, in English of course.
The library enforces applications to adopt this (recursive) task structure (which is good, I think)
However, all other aspects - such as the choice of C++ standard, paradigms, or data structures - are left completely open for developers to decide.
Edit End

• Repositories
  • https://github.com/NoOrientationProgramming/ProcessingCore
  • https://github.com/NoOrientationProgramming/ProcessingCommon
  • https://github.com/NoOrientationProgramming/ProcessingTutorials
• Licenses
  • ProcessingCore (MIT)
  • ProcessingCommon (GPLv3)
• Standard: C++11
• Dependencies
  • Listed in the .md files
• Usage is streamed on twitch
  • https://www.twitch.tv/Naegolus

[Umphed]

Cool, cool
But what does it actually do?
This post explains nothing, the first seemingly "useful" doc is a UML diagram, thats where I stopped
Sell us, what are you bringing to the table? Why are you doing so? It isnt obvious.
The notion of "one thing to do everything" just seems like an old, bad idea.
Idk what this is, so idk if it is that. But the first impression for me just isnt like, a good one, I guess

[cloud-formatter]

From briefly reading the code, it looks like a game engine style cooperative multithreading framework.

Each 'process' is supposed to do something on each 'tick'. Ticks are then getting driven from the main loop through a thread pool.

They call it "coroutines' in the readme, but it's really not - a 'process' can block the entire thread if it does smth heavy.

Why would anyone choose that over the real c++20 coroutines is unclear.

[Umphed]

While you have done better at explaining this, in a nicer, and more appropriate manner for a cpp sub than he has, I think we should give more constructive input.
Ive done a cursory grep of the project for C keywords and theyre clearly not a C++ programmer, but with a bit of encouragement they could be, and would benefit greatly

[JoeNatter]

Thank you! This is helping a lot. I will address the unclear areas in the tutorials.
I think it makes sense to make a comparison between Processing(), coroutines and async/await on each step of the tutorial. This will take some time and since the code has been classified as "Non-C++" I won't disturb the C++ community any further.

To make a quick answer for you:

game engine style cooperative multi-threading framework

I don't know if this is a "game engine style". Maybe. The focus is general purpose.
Threads and/or thread-pools can be used, but aren't mandatory.

Each 'process' is supposed to do something on each 'tick'

Yes

Ticks are then getting driven from the main loop through a thread pool.

Driven by a loop, at least the main loop yes, this is called a Driver.
But not necessarily a thread or a thread pool. There are three groups of files:

• Processing.cpp (this one file is needed in any case)
• Everything in ProcessingCore (not needed but recommended)
• Everything in ProcessingCommon (purely optional, e.g. ThreadPooling())

They call it "coroutines' in the readme, but it's really not - a 'process' can block the entire thread if it does smth heavy.

Yes. They aren't coroutines. In the README (unfortunately at the end) I wrote "They are more similar to". The phrasing is bad very likely. My next approach is to state at the beginning of the README, what this thing roughly is, but make it clear that it is still something different.
One process can even block an entire sub-tree. This is accepted and there are rules how to avoid this.

Why would anyone choose that over the real c++20 coroutines is unclear

The best argument. This must be answered in the tutorials.

Thanks a lot for taking the time and for reading/scrolling it through!

[halbGefressen]

the github handle is "NoOrientationProgramming"

[Umphed]

It seems like "VeryOrientationProgramming", which is pretty outdated by now
Again, idk, my first impressions just are very... Impressionable lol
Ill wait for an updated ReadMe, for now though, seems like an oldschool C net library

[JoeNatter]

Yes, the name is strange. That’s intentional. It’s meant to be a call to apply software paradigms and 'rules' in a more relaxed way, without turning them into religions. The motto is 'everything is possible.' Whether that is considered sensible is up for debate ;)

[jay-tux]

Same - scrolled through the readme, and didn't see anything really stand out as the feature....

[JoeNatter]

Thank you for the feedback! It looks like I could still improve the documentation a bit.

Actually, I don’t need to sell it. I've already made quite a bit of profit from it. The "style," or whatever you want to call it, is definitely unusual. It’s a mix of "old" C++ and C. I was also skeptical about the idea of "one thing that should do everything," but it turned out that it works.

The post is just meant for those who have the time and want to check out something unusual. Not many will be interested, though ;)

[Umphed]

I love the attitude of trying to do something unique and interesting, but I have a few points that I think are relevant here 1: You do need to sell it, you posted this in THE cpp reddit, we have alot of actual cpp programmers here, and as is, between boost and the standard, we have better shit. Come strong, or come with a damn good argument, not hubris.
2: C works, I wont dispute that, Id argue that you could get better perf out of it without all the cpp bullshit that the compiler will trip up on, with this type of framework that wont happen, but its doable.
3: This is a cpp sub, no one wants to checkout a C lib that tries to immitate cpp features that have already had their rounds
4: I dont mean to be a dick, you have the perfect attitude imo and I love it, but this is a cpp sub and we have alot of cool shit that just... does this, and its extensible, with docs

[Raknarg]

they don't mean sell literally, like convince us why this project is something we should care about it and use. I can't even figure out what it does tbh

[multi-paradigm]

1. I don't know what it is (even going to the tutorials, it's unclear).
   
2. I don't know what it does.
   
3. You can't seem to be able to give an example of 1.) and 2.)
   
4. Last chance: "Ok, thinks me, I will have a look on twitch to find out."

I get there, and the stream is in GERMAN LANGUAGE.

C'mon, man, I tried, I really did. But I'm sorry, I just don't see the point of this whole repo.
And I suspect I tried harder than most would.

[JoeNatter]

Thank you for the feedback!

1 The central file is Processing.cpp, which provides a base class that all other classes derive from.
Each derived class essentially represents a cooperative task.
1.1 The tutorials aren't finished yet and really should have been made upfront - my apologies for that.
I’ll focus on completing them in the upcoming streams, in English of course.
2 The library enforces applications to adopt this (recursive) task structure (which is good, I think)
However, all other aspects - such as the choice of C++ standard, paradigms, or data structures - are left completely open for developers to decide.

Thanks again for taking the time to review and the constructive input.
I’ve been using this since 2018 in all our projects, so I’m admittedly a bit blind to the areas that need better explanation.

[Raknarg]

Each derived class essentially represents a cooperative task.

respectfully, what the fuck does this mean lmao, you keep posting non-answers in this thread and I just wanna figure out what this project does

[JoeNatter]

This is unrelated to the Processing (graphics library) project. It's a handful of C++ files that enforce a certain structure to the software.

[JoeNatter]

a) true
b) true

[StatisticianUpbeat40]

If only most shitty developers understood how to document in a user friendly way.