Ada: how to send and receive objects between executables on separate machines

I would look for a solution based on Streams, sent over TCP.

If you want to implement your own blocking and hashing, you’ll probably need to write the raw stream to memory first so that you can tell how big the blob is and work out the checksum. A fairly straightforward approach to this would be here, spec and body.

For a solution that’s had a lot more work put into it, look at Dmitry Kazakov’s Simple Components’ Block Streams.

Ideally I'd want to mash it into a binary blob and be sent with a hash to confirm the message. Is there a decent way to do this in Ada?

As mentioned, the DSA [Annex E] is an excellent way to handle this, though with some caveats due to the implementations (rather than language) — the definitions of/for the DSA are broad enough that the transport could be mostly anything, so long as the interface (RPC- and Stream-based) is respected.

Things will be simple[r] if you structure your program with proper categorizations from the outset —see Pure, Shared_Passive, Remote_Types, and Remote_Call_Interface in the ARM, and the Ada Rational— rather than trying to shoehorn something extant into the DSA's required structuring. (That said, there are some cases where modifying an extant program to be DSA capable is rather simply a matter of adding the categorization pragmas/aspects and configuring+compiling.)

Note that Ada's containers are designed so that they can be used in DSA programs, and are all [IIRC] Remote_Types categorized.

I need to send some fairly large data-structures between instances of my running Ada program.

Also an option is ASN.1, which allows you to make a type-definition for some data in a language- and machine-independent manner. There are several ASN.1 compilers and a good chunk can generate Ada; here's one (written in F*, IIRC) used by the ESA and freely available open-source.

ASN.1 has an encoding scheme which is optimized for space, and so will give you the most compact on-the-wire representation.

Obviously json over https is an option. Not one I want to use as it's bigger than I'd like in terms of data overhead, but it will work for now.

Using HTTP and JSON directly is attractive for many people because it's "easy", though this ease is typically misleading: all the things that they don't do, such as range-checking values or validating the structure are offloaded to the programmer. — That said, you can make things modular and use generics to allow you to "swap-out" methods.

Generic
  Type Data(<>)           is private;
  Type Transport_Type(<>) is private;
  Target : However_you_address_the_target;
  with Function Encode(Input : Data) return Transport_Type;
Procedure Send( Value : Data );

and

Generic
  Type Data(<>)           is private;
  Type Transport_Type(<>) is private;
  with Function Decode(Input : Transport_Type) return Data;
Procedure Receive( Value : Transport_Type ) return Data;

Or something similar to this. I would rate this as less convenient than using the DSA, but also possibly a bit more simple, considering you [mostly] don't have to worry about categorization with this method.