Dada's Shared Memory Model: Rethinking Composability Without Garbage Collection

The ongoing exploration of memory management models reveals fundamental tensions between explicitness and ergonomics. Dada, an experimental language emerging from Rust's design philosophy, addresses this tension through a radical reimagining of shared ownership. Its approach eliminates common friction points in systems programming while introducing deliberate constraints that challenge conventional wisdom.

At the core of Dada's innovation lies its treatment of shared permissions. Where Rust requires explicit conversion between owned (T) and shared (Arc<T>) representations – often forcing deep clones or API redesigns when crossing abstraction boundaries – Dada treats sharing as a first-class language primitive. The .share operator transforms any owned (given) object into a shared entity, enabling shallow copying throughout nested structures. This propagates permissions transitively: extracting a field from a shared Character object automatically yields a shared String, mirroring the convenience of garbage-collected languages while retaining deterministic destruction.

This propagation mechanism hinges on two implementation constraints. Every object contains a hidden _flag field indicating its permission state (1 for owned, 2 for shared), while heap allocations prefix data with reference counts. When duplicating a shared Character, Dada performs shallow copies of all fields and increments ref-counts only for heap-allocated children like String buffers. Accessing ch.name on a shared character similarly produces a shared string through flag propagation and ref-count adjustments, effectively creating an Arc<String>-like wrapper without explicit syntax. This stands in stark contrast to Rust's rigid separation between value semantics and smart pointers.

The tradeoffs surface in Dada's operational costs. Each shared object copy incurs O(n) field copies and ref-count operations for immediate children, though without deep graph traversal. This predictable overhead enables Dada's 'opinionated' stance on memory layout: all objects must accommodate permission flags, and heap allocations always include ref-count headers. Such uniformity guarantees that semantically equivalent types share identical memory representations, eliminating Rust's notorious Arc<Vec<T>> versus Vec<Arc<T>> impedance mismatches. The language effectively trades marginal runtime overhead for radical composability, allowing independent code modules to exchange complex objects without coordination.

Critically, this model inverts Rust's philosophy of zero-cost abstraction. Where Rust pushes costs to explicit opt-in points (Arc::new, clone), Dada bakes shallow-copy semantics into shared object access. Proponents might argue this reduces cognitive load for concurrent programming; skeptics could counter that hidden ref-count operations complicate real-time systems. The design also implicitly discourages deeply nested structures – a potential limitation for complex domains. Nevertheless, Dada's experiment reveals how deliberate, system-wide conventions can resolve granular friction points that plague otherwise elegant ownership models.

Looking forward, this permission-propagation paradigm extends beyond shared objects. The promised ref and mut permissions suggest a comprehensive type-state system where access rights flow through composition chains. Should these ideas mature, they might inspire hybrid approaches in mainstream languages – perhaps even Rust itself – seeking middle ground between absolute control and ergonomic data sharing. For now, Dada serves as a provocative thought experiment: proof that memory management innovation requires not just new mechanisms, but willingness to impose judicious constraints.