The Mob core language and abstract machine (rev 0.2)

Most current mobile agent systems are based on programming languages whose semantics are difficult to prove correct as they lack an adequate underlying formal theory. In recent years, the development of the theory of concurrent systems, namely of process calculi, has allowed for the first time the modeling of mobile agent systems.Languages directly based on process calculi are, however, very low-level and it is desirable to provide the programmer with higher level abstractions, while keeping the semantics of the base calculus. In this technical report we present the syntax and the semantics of a scripting language for programming mobile agents called Mob. We describe the language’s syntax and semantics. Mob is service-oriented, meaning that agents act both as servers and as clients of services and that this coupling is done dynamically at run-time. The language is implemented on top of a process calculus which allows us to prove that the framework is sound by encoding its semantics into the underlying calculus. This provides a form of language security not available to other mobile agent languages developed using a more ah-doc approach.

💡 Research Summary

The paper introduces Mob, a high‑level scripting language designed for programming mobile agents, and defines its operational semantics through an abstract machine. Mob is built on top of the LSD π‑calculus, an extension of the π‑calculus that supports distributed execution and resource mobility. By encoding Mob constructs into this calculus, the authors obtain a formal, provably sound semantics, offering a level of language security unavailable in ad‑hoc mobile‑agent languages.

Mob adopts a service‑oriented model: agents declare the services they provide (provides) and the services they require (requires). At runtime, the bind primitive queries a network name resolver to dynamically obtain a binding to an agent offering the needed service. This dynamic coupling eliminates the traditional client‑server distinction; any agent can act as both provider and consumer. Type checking of service interfaces is performed at compile time, ensuring method‑call compatibility and contributing to language‑level security.

The language syntax blends object‑oriented and concurrent features. Agents and ordinary objects are created with new. Concurrency is expressed via fork, join, wait, notify, and mutual exclusion through lock/unlock. The go(host) primitive implements agent migration by serialising the entire virtual machine state and transferring it to a target host, where execution resumes transparently. Interaction with external systems is achieved through exec, allowing calls to services such as SMTP, FTP, HTTP, or to programs written in Java, Python, Perl, etc.

Semantically, Mob is defined in two steps. First, a Mob program is parsed into its syntactic categories (definitions, instructions, expressions). Second, each construct is translated into an LSD π‑calculus process. The abstract machine then describes state transitions over a configuration consisting of a set of agents, each containing a pool of threads, a shared heap, code, and bindings, together with a network resolver. The transition rules preserve the properties of the underlying calculus (confluence, dead‑lock freedom), thereby proving the soundness of Mob’s operational semantics.

Implementation leverages the existing TyCO runtime, which already compiles LSD π‑calculus programs to executable code on the Java Virtual Machine. The Mob front‑end compiler emits TyCO source, reusing TyCO’s back‑end and runtime infrastructure. Consequently, Mob inherits JVM portability while retaining fine‑grained control over agent state, essential for reliable migration across heterogeneous hosts.

The paper also enumerates syntactic restrictions (service definitions precede requirements, main method mandatory, limited placement of return, break, go, exit, etc.) and scoping rules for variables, agents, classes, and services, ensuring well‑formed programs.

In summary, Mob offers a formally grounded, service‑oriented, mobile‑agent language that combines high‑level scripting convenience with rigorous semantics, multi‑threaded concurrency, dynamic service discovery, and seamless migration, all built atop a proven process‑calculus foundation and an existing JVM‑based runtime.