Manuel Mazzara

Microservices: Yesterday, Today, and Tomorrow

Microservices is an architectural style inspired by service-oriented computing that has recently started gaining popularity. Before presenting the current state-of-the-art in the field, this chapter reviews the history of software architecture, the reasons that led to the diffusion of objects and services first, and microservices later. Finally, open problems and future challenges are introduced. This survey primarily addresses newcomers to the discipline, while offering an academic viewpoint on the topic. In addition, we investigate some practical issues and point out some potential solutions.

A Framework for Generic Error Handling in Business Processes

Recently the term Web Services Choreography has been introduced to address some issues related toWeb Services Composition. Several proposals for describing Choreography for Business Processes have been presented in the last years and many of these languages make use of concepts as longrunning transactions and compensations for coping with error handling. BPEL4WS, the most accredited candidate for becoming a standard in Choreography, provides three di.erent mechanisms for coping with abnormal situations: Exception Handling, Event Handling and Compensation Handling. The complexity of BPEL4WS makes it di.cult to formally de.ne this framework, thus limiting the formal reasoning about the designed applications. In this paper we advocate that three di.erent mechanisms for error handling are not necessary and we formalize a novel choreography language, based on the idea of event noti.cation as the only error handling mechanism. We can take advantages of this formal description in two ways. Firstly, this language represents by itself a proposal of simpli.cation for BPEL4WS including an unambiguous speci.cation. Secondly, an implementor of an actual BPEL4WS orchestration engine should implement simply this single mechanism providing all the remaining ones by compilation. Notably, the proposed framework is expressive enough to compare di.erent solutions for managing long running transactions such as BPEL4WS and StAC.

A Formal Framework for Web Services Coordination

Recently the term Web Services Choreography has been introduced to address some issues related to Web Services Composition and Coordination. Several proposals for describing Choreography for Business Processes have been presented in the last years and many of these languages (e.g. BPEL4WS) make use of concepts as long-running transactions and compensations for coping with error handling. However, the complexity of BPEL4WS makes it difficult to formally define this framework, thus limiting the formal reasoning about the designed applications. In this paper, we formally address Web Services Coordination with particular attention to Web transactions. We enhance our past work - the Event Calculus - introducing two main novelties: i) a multicast event notification mechanism, and ii) event scope names binding. The former enables an easier specification of complex coordination scenarios - such as E-commerce applications require - while the latter allows many new interesting behaviors which can be very useful in business scenarios: the introduction of private event scope names - used to deal with security and privacy - and a dynamic event scopes definition that can be used to manage multiple instances of the same application.

On Modelling and Analysis of Dynamic Reconfiguration of Dependable Real-Time Systems

This paper motivates the need for a formalism for the modelling and analysis of dynamic reconfiguration of dependable real-time systems. We present requirements that the formalism must meet, and use these to evaluate well-established formalisms and two process algebras that we have been developing, namely, Webpi and CCSdp. A simple case study is developed to illustrate the modelling power of these two formalisms. The paper shows how Webpi and CCSdp represent a significant step forward in modelling adaptive and dependable real-time systems.

A case study of web services orchestration

Recently the term Web Services Orchestration has been introduced to address composition and coordination of Web Services. Several languages to describe orchestration for business processes have been presented and many of them use concepts such as long-running transactions and compensations to cope with error handling. WS-BPEL is currently the best suited in this field. However, its complexity hinders rigorous treatment. In this paper we address the notion of orchestration from a formal point of view, with particular attention to transactions and compensations. In particular, we discuss webπ∞ an untimed subcalculus of webπ [15] which is a simple and conservative extension of the π-calculus. We introduce it as a theoretical and foundational model for Web Services coordination. We simplify some semantical and pragmatical aspects, in particular regarding temporization, gaining a better understanding of the fundamental issues. To discuss the usefulness of the language we consider a case study: we formalize an e-commerce transactional scenario drawing on a case presented in our previous work [12].

A formal semantics for the WS-BPEL recovery framework: the π-calculus way

While current studies on Web services composition are mostly focused -- from the technical viewpoint -- on standards and protocols, this work investigates the adoption of formal methods for dependable composition. The Web Services Business Process Execution Language (WS-BPEL) -- an OASIS standard widely adopted both in academic and industrial environments -- is considered as a touchstone for concrete composition languages and an analysis of its ambiguous Recovery Framework specification is offered. In order to show the use of formal methods, a precise and unambiguous description of its (simplified) mechanisms is provided by means of a conservative extension of the π-calculus. This has to be intended as a well known case study providing methodological arguments for the adoption of formal methods in software specification. The aspect of verification is not the main topic of the paper but some hints are given.

Data-driven workflows for microservices: Genericity in jolie

Microservices is an architectural style inspired by service-oriented computing that has recently started gainingpopularity. Jolie is a programming language based on the microservices paradigm: the main building block of Jolie systems are services, in contrast to, e.g., functions or objects. The primitives offered by the Jolie language elicit many of the recurring patterns found in microservices, like load balancers and structured processes. However, Jolie still lacks some useful constructs for dealing with message types and data manipulation that are present in service-oriented computing. In this paper, we focus on the possibility of expressing choices at the level of data types, a feature well represented in standards for Web Services, e.g., WSDL. We extend Jolie to support such type choices, and enable Jolie processes to act on data generically (without knowing which type it has in the choice). We show the impact of our implementation on some of the typical scenarios found in microservice systems. This shows how computation can move from a process-driven to a data-driven approach, and leads to the preliminary identification of recurring communication patterns that can be shaped as design patterns.

Microservices: How To Make Your Application Scale

The microservice architecture is a style inspired by service-oriented computing that has recently started gaining popularity and that promises to change the way in which software is perceived, conceived and designed. In this paper, we describe the main features of microservices and highlight how these features improve scalability.

Timing issues in web services composition

webπ is a recent process calculus introduced to formally specify Web Services composition. It extends the π-calculus with timed workunits, namely an asynchronous and temporized mechanism for events raising and catching. In this paper we encode Berger-Honda Timed-π in webπ timed workunits and we prove a simulation theorem. The overall perspective of this work is to make webπ comparable with both real composition languages and well established models for distributed components.

Microservices: a Language-based Approach

Microservices is an emerging development paradigm where software is obtained by composing autonomous entities, called (micro)services. However, microservice systems are currently developed using general-purpose programming languages that do not provide dedicated abstractions for service composition. Instead, current practice is focused on the deployment aspects of microservices, in particular by using containerization. In this chapter, we make the case for a language-based approach to the engineering of microservice architectures, which we believe is complementary to current practice. We discuss the approach in general, and then we instantiate it in terms of the Jolie programming language.