The DDO, DaaS Data Object, is the data unit exchanged between DaaS-IoT nodes. It separates application content from the mechanisms required to identify it, timestamp it, and deliver it across the network.
On the wire, a DDO uses a stable serialized representation composed of control fields and payload. Pointers, padding, alignment, and ABI remain confined to the platform's local memory; the same object can therefore cross C++, Java, Python, JavaScript, and embedded nodes.
The data object
A DDO combines four elements:
| Element | Function |
|---|---|
| Typeset | identifies the semantics and schema of the content |
| Origin | identifies the node that produced the object |
| Timestamp | places the object on the network's shared time axis |
| Payload | contains the bytes defined by the application |
These fields allow the receiver to answer four questions before interpreting the content: what am I receiving, who produced it, when was it produced, and how many bytes must I read?
DDO and DME roles
The DDO describes the data. The DME, DaaS Message Envelope, describes the transfer.
The envelope adds the information used by the core to reach the destination, manage the frame, and verify its consistency. The driver may add further framing required by the transport. None of these layers changes the meaning of the payload.
This separation allows the same DDO to be forwarded over multiple hops and through different drivers. The channel and transport envelope change; the typeset, origin, timestamp, and content remain unchanged.
The typeset is the on-wire schema
The typeset is a compact identifier associated with the contract that determines how payload bytes are interpreted.
A well-defined typeset specifies:
- schema version;
- field order and size;
- byte order of multibyte values;
- units of measurement;
- optional fields;
- maximum size;
- behavior when an unknown version is encountered.
For example, a measurement payload may be organized as follows:
| Offset | Size | Field |
|---|---|---|
| 0 | 1 | schema_version |
| 1 | 1 | flags |
| 2 | 8 | measurement_id |
| 10 | 4 | value |
| 14 | 2 | unit_code |
The typeset makes this layout shareable. The frame contains the schema identifier and the serialized payload; the schema may describe compact binary data or structured formats such as JSON, CBOR, or Protocol Buffers.
Deterministic serialization
A wire format must produce the same byte sequence for the same values. DaaS-IoT keeps the native representation separate from the transmitted representation specifically to make encoding and decoding deterministic.
The fundamental rules are:
- every field has a defined size;
- multibyte values use an established byte order;
- length precedes variable-size content;
- the decoder validates length before allocating or reading;
- control fields use a layout independent of platform alignment;
- the payload remains an opaque byte sequence until the typeset is recognized.
Sending a native structure directly violates these rules: the compiler may insert padding, enums may have different sizes, and endianness may vary between architectures.
Parsing: frame first, content second
The receiver processes a DDO in two passes.
Envelope validation
The core verifies that the frame is complete, that the destination is correct, and that the declared lengths are compatible with the received bytes. A truncated or inconsistent frame is rejected before it reaches the application.
Typeset decoding
After DME validation, the payload is associated with its typeset. The application decoder checks the schema version, sizes, and constraints before using the values.
This sequence isolates network framing from application content. The core can also carry typesets as opaque data when decoding is delegated to the application.
Large payloads and fragmentation
DDO size and link MTU are independent quantities. If the frame exceeds what the driver can transfer in a single operation, the transport layer segments and reassembles it.
The receiver exposes the DDO only after the frame has been fully reconstructed. An error in any chunk invalidates the entire object.
Fragmentation reconstructs one atomic DDO. Streaming delivers a sequence of data that can be consumed progressively.
Timestamp and origin are preserved
The origin identifies the DDO producer and remains unchanged while the object is forwarded through gateways and intermediate segments.
The timestamp is generated in the DaaS time domain. Its value is meaningful when the origin node is synchronized with the network. Intermediate nodes preserve it so that transport latency can be separated from production time.
Retries, duplicates, and ordering
Delivery applies the configured semantics above the wire format. Retries and different paths may produce duplicates or variations in arrival order; deduplication and ordering use application identifiers when required.
When the application requires deduplication or ordering, the typeset schema must include suitable fields:
- message ID;
- sequence number;
- correlation ID;
- state version;
- validity time window.
Application semantics place operation identifiers, idempotency keys, and sequence numbers in the payload.
Compatible evolution
The evolution of a typeset keeps the delivery mechanism stable. The two main strategies are:
- assign a new typeset to an incompatible representation;
- retain the typeset and add an explicit version when the decoder can handle multiple revisions.
New fields should allow an older decoder either to ignore them or to reject the object deterministically. The size, unit, and meaning of existing fields remain unchanged within the same schema version.
Wire-format responsibilities
The core manages the envelope, transport, and routing. The application defines the typeset, serializes the payload, and applies its semantics.
The DME handles delivery. The DDO preserves identity, time, and content. The typeset defines how to read the payload. Keeping these three contracts separate is what makes data exchange portable across different platforms and transports.