Supporting the evolution of event-driven service-oriented architectures using change patterns
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)
- et al.
A systematic review of software architecture evolution research
Inf Softw Technol
(2012) WSDL and BPEL extensions for event driven architecture
Inf. Softw. Technol.
(2010)- et al.
Size of treatment effects and their importance to clinical research and practice
Biol. Psychiatr.
(2006) - et al.
Evaluation of the comprehension of the dynamic modeling in UML
Inf. Softw. Technol.
(2004) - et al.
Change patterns and change support features - enhancing flexibility in process-aware information systems
Data Knowl. Eng.
(2008) Chapter 7 - one-way and higher designs for independent groups
- et al.
An value-centric event driven model and architecture: a case study of adaptive complement of SOA for distributed care service delivery
Expert Syst. Appl.
(2009) Domain specific languages for maintaining and analyzing changes in event-based architectures
8th International Workshop on Evolutionary Business Processes (EVL-BP 2015), Co-located with the 19th IEEE EDOC Conference
(2015)- et al.
Tying process model quality to the modeling process: the impact of structuring, movement, and speed
Statistical Power Analysis for the Behavioral Sciences
(1988)
Assessing the understandability of UML statechart diagrams with composite states–a family of empirical studies
Empir. Softw. Eng.
The adept project: a decade of research and development for robust and flexible process support - challenges and achievements
Comput. Sci. Res. Dev.
An algebraic semantics of event-based architectures
Math. Struct. Comput. Sci.
Modular event-based systems
Knowl. Eng. Rev.
Discovering Statistics Using R
NIÑOS take five: the management infrastructure for distributed event-driven workflows
5th ACM International Conference on Distributed event-based system (DEBS)
Identifying message flow in distributed event-based systems
Proceedings of the 2013 9th Joint Meeting on Foundations of Software Engineering
Capturing variability in business process models: the Provop approach
J. Softw. Maint. Evol.
Preliminary guidelines for empirical research in software engineering
Softw. Eng. IEEE Trans.
Developers ask reachability questions
Proceedings of the 32nd ACM/IEEE International Conference on Software Engineering
Programs, life cycles, and laws of software evolution
Proc. IEEE
On understanding laws, evolution, and conservation in the large-program life cycle
J. Syst. Softw.
The Power of Events: An Introduction to Complex Event Processing in Distributed Enterprise Systems
Distributed Event-Based Systems
Events and service-oriented architecture: the oasis web services notification specifications
IBM Syst. J.
Cited by (11)
On the impact of event-driven architecture on performance: An exploratory study
2024, Future Generation Computer SystemsEvent-Driven Architecture to Improve Performance and Scalability in Microservices-Based Systems
2022, Proceedings - International Conference Advancement in Data Science, E-Learning and Information Systems, ICADEIS 2022Research on Identification and Refactoring Approach of Event-driven Architecture Based on Ontology
2022, Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKEConstruct validity in software engineering
2021, TechRxivGrey relation analysis of 4S service pilot in high-end equipment manufacturing industry
2021, Journal of Computational Methods in Sciences and EngineeringProposing a Framework for Impact Analysis for Low-Code Development Platforms
2021, Companion Proceedings - 24th International Conference on Model-Driven Engineering Languages and Systems, MODELS-C 2021