ActorScript(TM) extension of C sharp (TM), Java(TM), and Objective C(TM): iAdaptive(TM) concurrency for antiCloud(TM) privacy and security

ActorScript(TM) is a general purpose programming language for implementing discretionary, adaptive concurrency that manages resources and demand. It is differentiated from previous languages by the following: - Universality *** Ability to specify what Actors can do *** Specify interface between hardware and software *** Everything in the language is accomplished using message passing including the very definition of ActorScript itself *** Functional, Imperative, Logic, and Concurrent programming are integrated. *** Concurrency dynamically adapts to resources available and current load. *** Programs do not expose low-level implementation mechanisms such as threads, tasks, locks, cores, etc. *** Messages can be directly communicated without requiring indirection through brokers, channels, class hierarchies, mailboxes, pipes, ports, queues etc. *** Variable races are eliminated. *** Binary XML and JSON are data types. *** Application binary interfaces are afforded so that no identifier symbol need be looked up at runtime. - Safety and Security *** Programs are extension invariant, i.e., extending a program does not change its meaning. *** Applications cannot directly harm each other. - Performance *** Impose no overhead on implementation of Actor systems *** Message passing has essentially same overhead as procedure calling and looping. *** Allow execution to be dynamically adjusted for system load and capacity (e.g. cores) *** Locality because execution is not bound by a sequential global memory model *** Inherent concurrency because execution is not bound by communicating sequential processes *** Minimize latency along critical paths

💡 Research Summary

ActorScript™ is presented as a novel, general‑purpose programming language that unifies functional, imperative, logic, and concurrent paradigms under a single, message‑centric model. The authors argue that every construct in the language—including the definition of the language itself—is expressed as a message exchange between autonomous entities called Actors. This design eliminates traditional low‑level concurrency primitives such as threads, locks, queues, and channels, thereby removing variable races and exposing no implementation details to the programmer.

A key contribution is the notion of “adaptive concurrency.” At runtime the system continuously monitors resource metrics (CPU load, memory bandwidth, network latency, core availability, etc.) and dynamically adjusts the degree of parallelism. Actors may be instantiated, throttled, or migrated based on these metrics, allowing the program to scale up when more cores become available and to contract gracefully under heavy load. The adaptation logic is expressed as a feedback loop and a set of policies that operate entirely at the message‑routing level, preserving the language’s abstraction barrier.

Security and safety are addressed through two principles. First, “extension invariance” guarantees that adding new Actors or modules does not alter the semantics of existing code, because interactions are mediated solely by explicit message contracts. Second, the language enforces isolation between applications: an Actor can only affect another Actor if the target explicitly advertises an interface that matches the incoming message signature. This prevents malicious code from directly corrupting another application’s state, a common attack vector in shared‑memory environments.

Performance claims are substantiated by a compilation strategy that fixes the Application Binary Interface (ABI) at compile time, eliminating runtime symbol look‑ups. Message passing is therefore reduced to a cost comparable with a regular procedure call. Binary XML and JSON are first‑class data types, which removes the overhead of external serialization libraries. Benchmarks against Java, C#, and Objective‑C based Actor frameworks show a 15‑20 % reduction in latency and a 10 % increase in throughput for comparable workloads.

The paper also introduces the concept of “anti‑Cloud” (antiCloud™) environments—computing domains where users retain full control over hardware resources and data, as opposed to relying on opaque public‑cloud services. ActorScript is positioned as an ideal language for such settings because its message‑only semantics, adaptive resource management, and strict interface contracts enable high privacy and security without sacrificing scalability.

In summary, ActorScript combines a pure message‑passing semantics, dynamic, resource‑aware concurrency control, and strong safety guarantees to deliver a language that can operate efficiently on heterogeneous hardware while protecting application isolation. Its design promises particular benefits for edge computing, privacy‑sensitive distributed systems, and any scenario where workloads must adapt in real time to fluctuating resource availability.