Supporting the evolution of event-driven service-oriented architectures using change patterns

https://doi.org/10.1016/j.infsof.2018.04.005Get rights and content

Abstract

Context

The components of an event-driven service-oriented architecture (EDSOA) are composed in a highly decoupled way, facilitating high flexibility, scalability and concurrency in SOA systems. Evolving an EDSOA is challenging because the absence of explicit dependencies among constituent components makes understanding and analysing the overall system composition difficult. The evolution of EDSOAs typically happens by performing a series of primitive changes—which can be described formally as change primitives.

Objective

In this article, we present our change pattern based approach for managing the EDSOA evolution as a novel design method supporting EDSOA evolution. The change patterns operate on a higher abstraction level than change primitives.

Method

To evaluate our approach, we have compared both time and correctness of changes in a controlled experiment comparing the understanding and performing of changes in EDSOAs. The experiment has been conducted with 90 students of the Software Architecture course at the University of Vienna. We compare the efficiency of 3 sets of change operations for modifying a given system architecture to obtain a desired architecture: a minimal set of 3 change patterns, an extended set of 5 change patterns, and a minimal set of 4 change primitives.

Results

Our results show that change patterns based evolution requires significantly less time to capture a similar level of correctness as the evolution based on change primitives, presuming that a certain level of transformation complexity is required. Furthermore, we did not observe a significant difference in the correctness level nor in the time required to perform the changes using an extended pattern set compared to a minimal set of patterns.

Conclusions

We clearly show the feasibility of our approach by developing a design method and tool support using a model-driven tool chain consisting of 3 domain-specific languages and empirically evaluating the approach in a controlled experiment.

Introduction

In recent years, distributed event-driven architectures have become widespread in their use in several domains such as real-time control systems, stock market and fast trading, network intrusion detection, sensor networks, healthcare monitoring, mobile and wearable computing (see e.g. [20], [26]). A main reason is that event-driven architectures provide solutions for developing distributed systems that facilitate high scalability, flexibility, and concurrency [20]. An event-driven architecture typically comprises a number of computational or data handling elements (i.e., components, actors) that communicate with each other by sending and receiving events [20]. Each component may independently perform a particular task, for instance, access a data storage, dispense cash from a credit card, or interact with users. Nowadays the components or actors in event-driven architectures are typically services, leading to a combination of event-driven and service-oriented architecture concepts, coined with the term event-driven service-oriented architecture (EDSOA) [13], [21]. More precisely, we use the term to describe event-driven architectures that are used to realize flexible service communication and orchestrations [13], [23], [50].

The communication style used in EDSOAs is based on implicit invocations performed by publishing an event (or message) to an event channel (also called event bus or message broker) instead of explicit invocations where one component is directly called via a reference [26]. As the exchange of events among the components is performed through the event channel, every component is in principle unaware of the others. This way a high degree of flexibility in the system is supported.

For example, the execution order of components can be changed (e.g., re-routing or adding some components) or any component can be replaced (e.g., with a bug-fixed or upgraded version) whilst the system is running. Additionally, EDSOAs support high scalability since the loosely coupled components can be executed concurrently and easily placed on different hardware nodes or virtual machines. However, the additional wanted degrees of flexibility, scalability, and concurrency through loose coupling might also increase the difficulty and uncertainty in understanding, maintaining and evolving these systems [8].

As requirements on software systems evolve over time, they have to be constantly maintained and changed [18]. More than one quarter of coding time is spent on implementing changes and investigating their impact [16]. By analyzing evolution of software systems, Weber et al. identify a set of change patterns that recur in many of existing software systems [45]. These patterns are specific for process-aware information systems (PAIS) where the execution of the software system is bound to a process schema, a prescribed rigid description of the behavior flow, and therefore, mostly cannot be changed during runtime or just slightly deviated from the initial schema [30], [34], [42]. As a result, these approaches are not easily applicable for EDSOAs where components are highly decoupled and the dependencies between components are subject to change at any time, even during the execution of the systems. Nevertheless, these patterns provide a basis for describing changes of the behavior in any information system.

To deal with the complexity and the large degree of flexibility of EDSOAs, a set of change operations that enable modifications in the system at different abstraction levels is proposed in our approach. Those change operations include low-level primitives (change primitives) for encapsulating the primitive change actions, such as adding or removing an actor or event, and high-level patterns (change patterns), that encompass a number of change primitives. An example of a change pattern is replacing an actor that represents a service call. This replacement pattern encompasses ‘removing and adding an actor’ primitives as well as ‘removing and adding events’ primitives. The provided set of patterns significantly extend the change patterns that are frequently occurring in most information systems [45] in order to deal with the specifics of EDSOAs. Hence our first research question addressed in this article is:

Research Question 1 (RQ1): Can the concept of change patterns (as defined for information systems by Weber et al. [45]) be used as a foundation for a design method for the evolution of EDSOAs, reflecting the specific changes required in EDSOAs?

In this article, we also investigate how the previously mentioned change operations (change patterns and change primitives) influence the process of performing changes or evolving an EDSOA. More precisely, we hypothesize a positive effect on the efficiency of performing changes in an EDSOA model using the change patterns compared to change primitive based changes. Hence, the second research question we studied was:

Research Question 2 (RQ2): If RQ1 can be answered positively, is there a significant positive influence on the efficiency of performing changes in an EDSOA model using the change patterns compared to change primitive based changes?

To study this research question, we conducted a controlled experiment where we compared the efficiency of change patterns and change primitives for modifying a given system architecture in order to obtain a desired one. The participants of our study were 90 students of the Software Architecture lecture at the University of Vienna. They were divided into 3 groups, and each of them was asked to modify a given system architecture (called the source architecture) using a given set of change operations in order to obtain a desired architecture (called the target architecture). For all groups the same 4 source/target pairs of EDSOA architecture models were given. The first group was provided with a set of 3 change patterns which also represents a minimal set of change patterns needed to perform any change in the system. The second group was provided with two additional patterns, to enable us to study to which extent additional higher-level abstractions help. Finally, the third group was provided with a set of 4 change primitives, which also represents a minimal set of primitives required to perform any change in the system. Our results show that, for the most complex model studied and the case where all models are considered together (the results for all studied models are summed up), the group with change primitives required significantly more time to reach a similar correctness level of pursued changes compared to the groups with change patterns. The obtained results provide empirical evidence that change patterns based evolution is generally more efficient than change primitives based evolution of EDSOAs, presuming that a certain level of transformation complexity is required. Moreover, the subjects used two additional patterns in the extended pattern set only to a limited extent and had problems with their correct application. No significant difference in the correctness level of pursued changes nor in the time required to capture those changes using the extended pattern set compared to the minimal set of change patterns was observed.

The major contribution of this article is the empirical study on efficiency of performing changes in EDSOAs, to find answers to our research questions RQ1 and RQ2.

In our previous work [1], [37], [38], [39], we investigate and adapt change patterns in the context of event-based architectures dealing with the lack of prescribed execution descriptions and the potentialy aribrarily changed relationships between constituent elements of a system. In order to deal with the complexity and the large degree of flexibility of event-based architectures, in this article we combine our prior works into a novel design method for the evolution of EDSOAs. As another novel major contribution, we present an empirical study in which we evaluated our approach with 90 participants.

This article is organized as follows: In Section 2, we discuss the related work, and in Section 3, we describe the required background on EDSOAs and change operations in their context. We then describe our change pattern Based design method for supporting EDSOA evolution in Section 4. Next, in Section 5 we discuss our empirical study on the efficiency of performing changes in EDSOAs using our pattern based approach. Finally in Section 6, we summarize our main contributions.

Section snippets

Related works on change patterns

Starting from the seminal work on the evolution of software systems by Lehman [17], several techniques for supporting different types of system evolutions have been investigated in different application domains [2]. One of the important works presented by Weber et al. [31], [44] identified a large set of change patterns that are frequently occurring in the most of today’s process-aware information systems (PAIS). The change patterns observed by Weber et al. targeted PAISs in which the execution

Background on event-driven service-oriented architectures

To support performing specific changes in EDSOAs as well as understanding their impacts, we assume that each service exposes an event-based interface that specifies a set of events that the service can receive (the input events) and a set of events that the service will emit (the output events). The input events trigger the execution of a certain service so the service is considered as “consumer”. In turn, a service can also emit one or many output events after its execution finishes and

Change pattern based design method for supporting EDSOA evolution

Maintaining EDSOAs is challenging because of the absence of explicit information on the dependencies of its components. Therefore, knowledge about the dependencies between components has to be extracted from source code. Assisting techniques for analyzing the impacts of certain changes are missing, hindering the implementation of changes in EDSOAs. Specifying a design method supporting the evolution of EDSOAs allows developers to focus on their concepts, like events and event emitting or

Empirical study description

As RQ1 could be positively answered, we have further studied RQ2 in a controlled experiment. For the study design, we have followed the experimental process guidelines proposed by Kitchenham et al. [14] and Wohlin [48]. The former was primarily used in the planning phase of the study while the later was used for the analysis and the interpretation of the results.

Conclusion

This study presents a change pattern based design method for supporting evolution in EDSOAs, together with a controlled experiment on understanding and performing changes in EDSOAs using change operations at different abstraction levels (i.e., low-level change primitives and high-level change patterns). We have clearly shown in the feasibility of our approach by developing a design method and tool support using a model-driven tool chain consisting of 3 domain-specific languages. In our

Acknowledgment

This work was supported by the Austrian Science Fund (FWF), project: P24345-N23.

References (50)

  • J.A. Cruz-Lemus et al.

    Assessing the understandability of UML statechart diagrams with composite states–a family of empirical studies

    Empir. Softw. Eng.

    (2009)
  • P. Dadam et al.

    The adept project: a decade of research and development for robust and flexible process support - challenges and achievements

    Comput. Sci. Res. Dev.

    (2009)
  • J.L. Fiadeiro et al.

    An algebraic semantics of event-based architectures

    Math. Struct. Comput. Sci.

    (2007)
  • L. Fiege et al.

    Modular event-based systems

    Knowl. Eng. Rev.

    (2002)
  • A. Field et al.

    Discovering Statistics Using R

    (2012)
  • S. Ganesan et al.

    NIÑOS take five: the management infrastructure for distributed event-driven workflows

    5th ACM International Conference on Distributed event-based system (DEBS)

    (2011)
  • J. Garcia et al.

    Identifying message flow in distributed event-based systems

    Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering

    (2013)
  • A. Hallerbach et al.

    Capturing variability in business process models: the Provop approach

    J. Softw. Maint. Evol.

    (2010)
  • B.A. Kitchenham et al.

    Preliminary guidelines for empirical research in software engineering

    Softw. Eng. IEEE Trans.

    (2002)
  • T.D. LaToza et al.

    Developers ask reachability questions

    Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering

    (2010)
  • M. Lehman

    Programs, life cycles, and laws of software evolution

    Proc. IEEE

    (1980)
  • M.M. Lehman

    On understanding laws, evolution, and conservation in the large-program life cycle

    J. Syst. Softw.

    (1984)
  • D.C. Luckham

    The Power of Events: An Introduction to Complex Event Processing in Distributed Enterprise Systems

    (2001)
  • G. Mühl et al.

    Distributed Event-Based Systems

    (2006)
  • P. Niblett et al.

    Events and service-oriented architecture: the oasis web services notification specifications

    IBM Syst. J.

    (2005)
  • Cited by (11)

    View all citing articles on Scopus
    View full text