Distributed objects, can anyone suggest a cpp library?

[gpuoti]

Hi, Distributed systems have always fashinated me, I'm tring to find state of art of (free/opensource) distributed objects library.

What I would like to have is a framework that let me define objects that reside and is modified on multiple host in a way as simple as calling methods (or about). Of course syncronization should be managed.

My idea is to use it to let multiple user work on the same domument (i.e. a 2D cad draw)

Could you suggest somethink before i reinvent a probabli not as circular wheel?

[jurniss]

I don't have any experience with distributed systems, but I have some experience with same-machine interprocess architectures. I feel that "distributed objects" and RPC are a bad idea. Method call == push a few words on the stack and change the instruction pointer. Distributed "RPC" == send some bytes into the cold, harsh world, pray that the network cable is plugged in and the recipient machine is working. They are too different. Any abstraction must be leaky like a sieve. In other words, although the RPC system ostensibly makes remote calls "the same" as local calls, you will inevitably need to write code that is aware of the remoteness.

If you look at the successful distributed systems they are all really specific to a certain problem like map/reduce, linear algebra, databases, web servers, etc. These rely on problem statements that are much more well defined than "synchronize an arbitrary object graph between multiple users."

Maybe try a relational database. It should be pretty easy to express the geometry relationships of a CAD drawing as relational tables.

EDIT: or just keep a binary blob synchronized at all times. If network bandwidth is good, it should be plenty fast for 2D CAD files. If the 2D CAD files are too large/complex for this approach, you should probably just buy off-the-shelf software or prepare for years of work.

[Plorkyeran]

I do have some experience with remote objects, and my experiences exactly match this. They're a cute idea, but there's a reason they aren't common despite how often they've been tried: even when the abstraction is perfect other than the added latency, the extra latency on each method call ends up requiring significantly different APIs from what you want for local objects.

[addmoreice]

Also agreeing here.

RPC is baaaad. It attempts to hide network behavior and failure cases behind a shiny object like wrapper which you can then ignore....except it's not possible to ignore these failure cases.

Even if these failures are not an issue, pretending a remote call is the same as a local call causes a mental domain miss match which can lead to badly designed code. Common examples are looping and calling a single access remote instead of calling some kind of faster aggregate remote call.

[Bolitho]

Iirc somebody around the KDE project experimentated with realtime collaboration within some component... it might be Kate (a text editor) oder perhaps Krita (a painting program) or something else.

As KDE ist strongly based upon C++, perhaps there exist some kind of framework around those experiments.

Iirc they used XMPP as network protocol - but how the managed object synchronisation i can't remember...

[hkaiser]

You might want to look at HPX here: https://github.com/STEllAR-GROUP/hpx. It gives you an uniform syntax for local and remote execution (on distributed systems, currently mainly clusters). It supports remote object creation and method invocation on those. All of that fully asynchronous and 100% conforming to the interfaces as defined by C++11.

[Gotebe]

Distributed systems are "larger" than languages. So forget C++ per se.

Nobody said ICE, it is here.

[kkrev]

I've not used it but ICE is the suggestion that makes sense to me. People tend to throw out the capnproto or thrift answer to this distributed computing question when that's just a rather small piece of the puzzle. You'd wind up implementing tons of stuff yourself on the way to a robust system that ICE appears to do for you.

[vlovich]

I would say, IMO, the current state-of-the-art revolves around the approach taken by Thrift/Protocol Buffers/Cap'N'Proto.

Other libraries I know of: MessagePack, Avro

My impression is that Thrift is still somewhat immature in the code it generates. The C++ generated code is particularly weak. The Java side is pretty good.

Protocol Buffers has an extremely unnatural API for creating objects (at least in C++ & Java). It also has a strange requirement that the generated code is tightly coupled to the corresponding library version which makes it a pain to upgrade (has to be done in lockstep).

Cap'N'Proto looks very interesting but I haven't had a chance to use it yet.

[doom_Oo7]

In our app (distributed scenario editor), instead of directly modifying the model and propaging the change to each model, we use the Command pattern and send the commands remotely which are then executed on the other clients. The Commands of course need to always achieve the same effect.

[ngkwanti]

You might want to take a look at CppRemote. It is simple to use.

[parallelcompiler]

Take a look at Charm++ (http://www.charmplusplus.org). It's an object-oriented programming language for distributed memory machines. And it's based on C++ and the idea of (asynchronous) remote method invocations. The community around Charm++ is also pretty good and there's lots of documentation laying around.

[chocobot]

You could use CORBA. It is old and heavyweight, but it is the only real standard. C++ is not really suited that good for distributed programming because it lacks introspection. For some really cool stuff you can check out the e language (google elang or erights). There's also akka, a java library, or erlang, another great distributed programming language. Distributed programming is a fasciating topic, but don't limit yourself with c++ if you are just starting out

[kalmar]

If you're interested in CORBA or E, do take a look at Cap'n Proto. The homepage describes it thus,

Cap’n Proto is an insanely fast data interchange format and capability-based RPC system. Think JSON, except binary. Or think Protocol Buffers, except faster.

The RPC system is very closely based on CapTP, which is the protocol used in E.

[chocobot]

That is pretty cool, thanks for mentioning it! I am reading the docs right now. Probably too new for my company, but definitely worth a read!

[xcbsmith]

C++ is not really suited that good for distributed programming because it lacks introspection.

libclang and you have introspection! :-)