There is increasing interest in the use of formal techniques in object-oriented programming languages, e.g., contracts in Eiffel, JML/Java, Spec#/C#, and Spark/Ada. The intent behind the use of these techniques is, amongst other things, to support automated analysis (e.g., theorem proving, model checking, simulation), and improve documentation and reusability. There is also increasing interest in extending languages that support these formal techniques to support the production of concurrent, real-time, and distributed systems. Some of these extensions build on threading libraries; other extensions are more non-standard. For example, one proposal for extending Eiffel is SCOOP (Simple Concurrent Object-Oriented Programming), a novel concurrency mechanism that adds a single keyword, separate, to the language, while supporting asynchronous calls and lazy evaluation. This proposal is fully integrated with the Eiffel language, in terms of its support for Design-by-Contract.
These extensions pose a number of challenging research questions, both theoretical and practical. Practical questions include efficient design and implementation of a concurrency model while allowing extension to real-time and multi-processor distribution. Theoretical questions include how to extend reasoning and analysis frameworks to support concurrency, real-time and distribution. A key goal in attempting to address these questions is to formulate sensible, practical answers to them while maintaining the design principles that are ever-present in the underlying language. Answering these questions will influence the design and evolution of the languages, but will likely also have a wider impact, on the study of concurrency and real-time in middleware and infrastructure, e.g., Enterprise JavaBeans and .NET.
There have been previous workshops and conferences focusing on formal techniques in object-oriented programming, and also on concurrency in object-oriented programs. This is the first event to focus specifically on concurrency, real-time and distribution extensions for object-oriented languages supporting formal techniques.
To this end, original research contributions are sought in all areas related to extending Eiffel-like languages to concurrent, real-time, and distributed systems development. Topics of interest include, but are not limited to:
- Semantics of models of concurrency in Eiffel-like languages, e.g., formal specifications of SCOOP, threading extensions to Spark.
- Implementations of models of concurrency in Eiffel-like languages, e.g., implementations of SCOOP, active objects implementations in C#. This would also include extensions to analysis tools, e.g., Spec#, for concurrency.
- Designs and implementations of alternative models of concurrency in Eiffel-like languages, e.g., active objects.
- Real-time extensions to Eiffel-like languages, including topics such as duels, timing analysis, and schedulability.
- Distributed extensions to Eiffel-like languages (both library-based and language-based), including handling security, exception handling, and garbage collection.
- Reasoning about concurrent programs in Eiffel-like languages, e.g., proof systems, refinement rules, model checking support.
- Case studies in implementing concurrent systems in Eiffel-like languages.
- Empirical/quantitative comparisons of concurrency models in Eiffel-like languages
- Comparisons of concurrency in Eiffel with other languages, e.g., Java, Ada, C++.