Modern software systems tend to be distributed, event-driven, and asynchronous, often requiring components to maintain multiple threads of control for message and event handling. In addition, there is increasing pressure on software developers to introduce concurrency into applications in order to take advantage of multicore and many-core processors to improve performance. Yet concurrent programming remains difficult and error-prone. The need to train the software development workforce in concurrent programming has become increasingly urgent as the CPU frequency growth no longer provides adequate scalability. As a result of that, a large number of developers in the current software development workforce continue to find it hard to deal with thorny concurrency issues in software design and implementation.
The projects designs a new programming language construct called Capsules, an improved abstraction for concurrency that can hide the details of concurrency from the programmer and allow them to focus on the program logic. The main goal of this project is to conduct a formal study of the semantic properties of capsules, efficiently realize this abstraction in industrial strength tools that will be globally disseminated, and empirically evaluate performance and software engineering properties of a programming language design that incorporates this abstraction. This approach seeks to create software that is correct with respect to concurrency by construction. Its success will aid and enable more reliable development of concurrent software. While it makes great sense to develop explicit concurrency mechanisms, sequential programmers continue to find it hard to understand task interleavings and non-deterministic semantics. Thus, this research on the capsule abstraction, if successful, will have a large positive impact on the productivity of these programmers, on the understandability and maintainability of source code that they write, and on the scalability and correctness of software systems that they produce.
