Section: Overall Objectives

Overall Objectives

Nowadays, distributed applications can be found on an ever increasing number of interconnected computing infrastructures, ranging from small scale embedded devices to personnal devices, including laptops, desktops, palmtops, and tablets, and finally to large scale data-centers and high performance computing infrastructures. In addition to this inter-platform heteregeneity, we also face higher levels of intra-platform hetrogeneity, with the advent of multi-core architectures, virtual threads, GPUs, and new virtualization technologies. Programming distributed applications in such an heterogeneous environment, with high level of confidence both in terms of performance and security, is still a challenge, and raises many questions.

The overall objective of Scale is to provide a unified programming language and execution model for such a large-scale multi-level parallelism. We want to contribute to the design of the programming languages that will be used to program large-scale distributed applications in 2020. The characteristics we want to put forward are: ease of programming and guarantees of correctness. For this purpose our approach mixes distributed systems, theory of programming languages, middleware implementations, and resource management. Guided by this interaction the Scale team contributes to the creation of safe and efficient environments for programming and running distributed applications.

The Scale team and its positioning

The strength of Scale is to put together researchers in programming languages, from a rather theoretical perspective, with researchers in middleware and object-oriented programming with a strong expertise on distributed systems and their applications.

During the last decade, the landscape of programming languages for distributed systems has changed. Actors and active objects have gained interest both from the industrial point of view, as illustrated by the success of Scala and Akka (http://akka.io ), and from the academic point of view, for example through the projects around ABS and Creol. Our new proposal, multi-active objects, gives a novel alternative in this world. It is expected to be more efficient and more easily applicable than academic languages, but with a better formalisation and more proved properties than the languages targeting industrial usage. In particular we believe we are able to provide the expertise allowing the transfer of academic results on active objects into language constructs and runtime support that can be adopted by industrial platforms like Akka.

The global objective to make safe programming accessible to most programmers directs the choice of the target programming language for our developments toward Java. This choice is not only the result of our expertise, but also because it is well known, accessible by most programmers, and also because the underlying JVM can be shared with other languages. This last feature opens interesting perspectives in terms of sharing and reuse of our software contributions. However, this choice is not exclusive. In particular, the approach we propose should be easy to transfer to other programming languages.

While we still rely on active objects as a medium-grain parallelism abstraction, we also propose new ways of parallelizing the execution inside active objects (fine-grain parallelism), and autonomic ways to deploy and run the coarse-grain entities composing the application. However, these various levels of programming and execution environments cannot be designed independently. They all rely on a small set of common abstractions. Typically the service of a request is a notion that can be reasoned about at all the considered levels. We think that providing such unifying programming and execution abstractions, and their formal specification, makes the originality and the strength of Scale , while unifying our contributions.

Finally, the Scale team wants to put a strong emphasis on safety for distributed applications. We want to apply our expertise about reasoning on language, programs, and protocols in order to ensure the safe execution of distributed systems and applications. The fact that we are able to prove the safe behaviour of applications that achieve performances comparable to unproven and unsafe distributed systems is probably the biggest strength of the Scale team. Concerning safety, our approach is threefold: 1) provide high-level programming abstractions that makes the writing of distributed programs easier (and thus reduce the chances to write bugged programs); 2) prove the correctness of the platform we propose, by proving both properties of the programming language and properties on the tools and protocols we use; and 3) provide tools so that the users can specify the behaviour of their application and verify that it is correct.

Research challenges and objectives

To summarise, the challenges we address in the Scale team are the following:

• Safe and easy programming of large-scale distributed applications. We work to design a unified programming model for the development of applications mixing local concurrency, e.g. at the level of multicore hardware, and large-scale distributed parallelism, like in cloud architecture. The language is based on the multi-active object language we designed in the last two years, extended with features for easing its programming.

  Among the improvements of the language, the strongest challenges are: 1) provide in the same programming model, simplicity of programming for non-experts, and optimisation capabilities for advanced users; and 2) safety guarantees, including a wide variety of analysis methods supporting the development of correct applications; these analysis methods include static verification of Java annotations and behavioural analysis of dynamic systems of unbounded size.

• Easy, safe and efficient execution of large-scale distributed applications. We work to design a runtime environment supporting our approach and showing its practical effectiveness. Also, and more originally, this challenge includes resource management aspects, and the possibility for the programmer to easily express resource requirements on his/her applications. Finally, the runtime support for application is also crucial here, and will include in Scale a wide range of aspects ranging from elasticity concerns to support for distributed debugging.

  Here, the biggest research challenges are: 1) allow the non-expert programmer to express constraints on his/her program that will allow us to better deploy the application and run it efficiently; 2) prove the correctness of the runtime platform and the tools we propose.

• Experiments on real life scenarios. Those scenarios will mostly be taken from big-data and simulation application domains.

  Here, the biggest research challenges are 1) Provide a convenient environment for programming and running big-data analytics. One of the key challenge we want to address is how to scale and adapt analytics at runtime both from the technical and from the business point of views. The streaming data variability, velocity, and volume evolve at runtime, so should the analytics computation. Even the computation itself might evolve depending on preliminary results, thus the business computation also has to be adaptable. 2) Provide an efficient support for the distributed execution of large discrete-event simulations; we target deployment of large instances of component-based simulation models, and processing of the large amount of data samples produced by simulations.