text: abstract
  runtime adaptation (ra) is a technique prevalent to long-running, highly available software systems, whereby system characteristics are altered dynamically in response to
  runtime events, while causing limited disruption to the execution of the system. actorbased, concurrent systems are often used to build such long-running, reactive systems
  which require suffering from limited downtime. this makes runtime adaptation an appealing technique for mitigating erroneous behaviour in actor-systems, since mitigation
  is carried out while the system executes.
  in this dissertation we focus on providing effective adaptations that can be localised
  and applied to specific concurrent actors, thereby only causing a temporary disruption to
  the parts of the system requiring mitigation, while leaving the rest of the system intact.
  we make the application of localised adaptations efficient through incremental synchronisation, whereby the specifier can strategically suspend specific parts of the system,
  whenever this is strictly required for ensuring that adaptations are effectively applied.
  we also study static analysis techniques to determine whether the specified incremental
  synchronisation is in some sense adequate for local adaptations to be carried out.
  we thus identify a number of generic adaptations that can be applied to any actor system, regardless of its design and the code that it executes. we implement the identified
  adaptations as an extension of an existing runtime verification tool for actor-systems,
  thereby creating a ra framework for monitoring and mitigating actor systems. in parallel to our implementation we also develop a formal model of our ra framework that
  further serves to guide our implementation. this model also enables us to better understand the subtle errors that erroneously specified adaptation scripts may introduce.
  we thus develop a static type system for detecting and rejecting erroneous adaptation
  scripts prior to deployment, thereby providing the specifier with assistance for writing
  valid scripts. although the static typesystem analyses scripts with respect to certain assumptions, we do not assume that the monitored system abides by these assumptions.
  we therefore augment our ra framework with dynamic checks for halting monitoring
  whenever the system deviates from our assumption. based on this dynamically checked
  model of our ra framework, we prove type soundness for our static type system.
  as a result of this dissertation we thus implement and formalise a novel a runtime
  adaptation framework for actor systems as extension to an existing runtime verification tool. furthermore, exploring the mixture of static and dynamic typechecking, in the
  context of runtime verification, for the purpose of adaptation is also quite novel. this exploration lead to the developing a novel type analysis technique for detecting erroneously
  specified runtime adaptation scripts.