Abstract
We consider a methodology for flexible software design, runtime programming, defined by recurrent, incremental software modifications to a program at runtime, called runtime patches. The principles we consider for runtime programming are model preservation and scalability. Model preservation means that a runtime patch preserves the programming model in place for programs - in terms of syntax, semantics, and correctness properties - as opposed to an "ad-hoc", disruptive operation, or one that requires an extra level of abstraction. Scalability means that, for practicality and performance, the effort in program compilation required by a runtime patch should ideally scale in proportion to the change induced by it. We formulate runtime programming over an abstract model for component-based concurrent programs, defined by a modular relation between the syntax and semantics of programs, plus built-in notions of initialization and quiescence. The notion of a runtime patch is defined over these assumptions, as a model-preserving transition between two programs and respective states. Additionally, we propose an incremental compilation framework for scalability in patch compilation. The formulation is put in perspective through a case-study instantiation over a language for distributed hard real-time systems, the Hierarchical Timing Language (HTL). © 2011 IEEE.

Abstract
We propose a methodology for flexible software design, runtime programming, by means of incremental software modifications at runtime. Runtime programming acknowledges that software designs are often incomplete, and require the flexibility of change, e.g., fixing bugs or introducing new features, without disruption of their service. This flexibility is much needed for critical software that generally needs to handle uncertainty, e.g. cloud computing or cyber-physical systems, due to dynamic requirements of composition, service, or performance. Runtime modifications should be allowed recurrently, and, thus, be handled as a common case of system functionality in predictable and efficient manner, with proper understanding of inherent functional and non-functional aspects. The work in many diverse research communities with related concerns typically tends to take a partial and domain-specific view of the problem, hence comprehensive and general methodologies are in order. In this extended abstract, we make a summary of the runtime programming proposal of [4]. The work follows up on a preliminary formulation of runtime programming [3], and work on modular compilation of real-time programs [2]. © 2012 Springer-Verlag.

Abstract
We describe the architecture and the implementation of the MIKADO software framework, that we call IMC (Implementing Mobile Calculi). The framework aims at providing the programmer with primitives to design and implement run-time systems for distributed process calculi. The paper describes the four main components of abstract machines for mobile calculi (node topology, naming and binding, communication protocols and mobility) that have been implemented as Java packages. The paper also contains the description of a prototype implementation of a run-time system for the Distributed Pi-Calculus relying on the presented framework.

Abstract
We present a service-oriented scripting language for programming mobile agents in distributed systems. The main novelty of the language we call MOB, is the integration of the service-oriented and mobile agent paradigms. MOB is also encoded onto a process calculus with a well studied semantics. The encoding provides a specification for the front-end of the language compiler and allows us to use, for the back-end and for the run-time system, a compiler and a virtual machine previously developed for the process calculus.

Abstract
In this paper we present MOB, a service-oriented scripting language for programming mobile agents in distributed systems. The main feature of the language is the integration of the service-oriented and the mobile agent paradigms. MOB is encoded onto a process calculus with a well studied semantics which provides us with a tool to prove the soundness of the language relative to the underlying calculus. Copyright 2006 ACM.

Abstract
We present a process calculus that models the communication and computational aspects of sensor network applications. The calculus focuses on a basic set of primitives for programming sensor networks that support code deployment, communication and local processing, and provides a very expressive core-language. The calculus and its associated theory provide the tools to verify the robustness of sensor network applications and protocols. © 2007 IEEE.