The wide availability of multi-core processors and the ubiquitous presence of the Internet lead to new challenges in software design and implementation. Software has to be written in a parallelizable way to profit from multiple cores. Interaction with distributed Internet services requires coping with message delays and network failures. These challenges reach application domains, like desktop applications, which have been mainly written in a sequential way in the past. The concurrency model of mainstream object-oriented programming languages is based preemptively scheduled threads, which concurrently work on a shared object-heap. This programming model is highly prone to race conditions, i.e., hard to find concurrency-related errors that are not easily reproducible. To synchronize threads and prevent data races, operating system mechanisms like locks have to be used. Experience shows that this programming model is too difficult for most programmers, is not very modular, and is not well suited for the behavioral description of software components. Furthermore, the thread-based model is not appropriate for realizing distributed systems, due to its inherent synchronous communication model.
This thesis proposes a novel programming model for concurrent and distributed, object-oriented systems. The so-called cobox model generalizes the concept of active objects to concurrent, object-oriented runtime components, called coboxes. CoBoxes have their own, local object-heap, which cannot be directly accessed by other coboxes. CoBoxes communicate by asynchronous method calls with standard objects as targets, where multiple objects of a single cobox can be used for interaction. Computations inside coboxes happen via standard object-oriented programming, combined with cooperative multi-tasking. The thesis at hand presents a formalization of the semantics of the cobox model in a core calculus. The calculus is proved type-sound and several additional properties are formally covered. The dynamic semantics of the core calculus is implemented in the rewriting logic framework Maude. In addition, the cobox model is realized in a practical programming language called JCoBox, which extends standard sequential Java. JCoBox is implemented by a Java compiler extension as well as a JVM bytecode rewriter. The performance of JCoBox can compete with state-of-the-art actor implementations for the JVM. The practicability of the proposed programming model and language is evaluated by the design and implementation of several concurrent applications.