The microservice architecture structures an application as a collection of small autonomous services, enhancing development practices and maintainability. It impacts system performance and scalability, which are influenced by the architectural design, the system deployment, and usage. In this paper, we present a systematic literature review (SLR) on the assessment of performance and scalability in the microservice architecture, aiming to identify research gaps and assess the current state of knowledge. The review protocol screened 801 studies, selecting 29 primary studies for detailed analysis. We perform comparisons of studies and try to identify the main gaps in current research and suggest areas for further investigation. The main conclusion is that the current research partially addresses the dimensions associated with the performance and scalability qualities of microservice systems. In particular, there is a lack of comparative studies of architectural patterns and styles or comparable assessment models and methods. Therefore, a systematic approach is lacking and the paper reports a set of open research trends to guide researchers in the area of microservice-based software architecture quality assessment.

Online evaluation systems, pervasive nowadays, are known to be susceptible to higher fraud risks. This work proposes a novel and robust method to detect potential fraud acts in online multiple-choice question (MCQ) exams. For the first time, the communication probability between the examinees is statistically assessed based on the concordance of responses and answer time against null expectations and is subsequently used to identify potential fraud behavior. The model is sensitive to the direction of communication acts, distinguishing content consumption from production, as well as multiwise communication channels. Online remote tests from engineering courses at Técnico Lisboa are used as a case study. We show that the cumulative contribution of concordant responses between students, when recurrent, offers a way of signaling fraud behavior. Separating content production from consumption reveals the underlying student role played in potential fraud acts. Collusion behavior is assessed against null models of fraud and conformity, and therefore being statistically framed and offering a solid criterion to guide tutors in ascertaining fraud and discouraging communication.

Recent research has proposed different approaches on the automated identification of candidate microservices on monolith systems, which vary on the monolith representation, similarity criteria, and quality metrics used. On the other hand, they are generally limited in the number of codebases and decompositions evaluated, and few comparisons between approaches exist. Considering the emerging trend in software engineering in techniques based on the analysis of codebases’ evolution, we compare a representation based on the monolith code structure, in particular the sequences of accesses to domain entities, with representations based on the monolith development history (file changes and changes authorship). From the analysis on a total of 468k decompositions of 28 codebases, using five quality metrics that evaluate modularity, minimization of the number of transactions per functionality, and reduction of teams and communication, we conclude that the changes authorship representation of codebases with many authors achieves comparable or better results than the sequences of accesses representation of codebases with few authors with respect to minimization of the number of transactions per functionality and the reduction of teams.

As monolithic applications grow in size and complexity, they tend to show symptoms of monolithic hell, such as scalability and maintainability problems. To help suppressing these problems, the microservices architectural style is applied. However, identifying the services within the monolith is not an easy task, and current research approaches emphasize different qualities of microservices. In this paper we present an approach for the automatic identification of microservices, which minimizes the cost of the monolith’s functionalities redesign. The decompositions are generated based on similarity measures between the persistent domain entities of the monolith. An extensive analysis of the decompositions generated for 121 monolith systems is done. As result of the analysis we conclude that there is not a similarity measure, neither a combination of similarity measures, that provides better decomposition results in terms of complexity associated with the functionalities migration. However, we prove that it is possible to follow an incremental migration process of monoliths. Additionally, we conclude that there is a positive correlation between coupling and complexity, and that it is not possible to conclude on the existence of a correlation between cohesion and complexity.

Abstract In the process of migrating a monolith to a microservice architecture, functionalities which execute on top of a single database as ACID transactions, have their execution split between several databases, one for each microservice. Therefore, the complexity of functionality migration increases, because of the lack of isolation of the functionality execution, which has to be handled by following an eventual consistency model. On the other hand, the object‐oriented approach, commonly followed in the development of monolith systems, promotes fine‐grained interactions in the functionalities implementation, which further increases the migration effort due to the large number of remote invocations between microservices, because it increases the number of microservices transactions that have to eventually be consistent. The main contribution of this paper is a heuristic method to help the software architect on the identification of functionality refactorings, to reduce the effort required to migrate the functionality to microservices when applying the SAGA pattern in the functionality microservices implementation. The heuristic accuracy and efficiency of the method is evaluated using a dataset extracted from 78 codebases and by comparing the results with expert refactorizations. Additionally, a performance analysis of the heuristic implementation is done.

This paper discusses how quizzes are applied within the field of software engineering learning and how quizzes can help self-regulate student learning. For this, a systematic mapping that selected the most relevant studies on the use of quizzes in education was performed, aiming to clarify their relationships and mutual impacts. Our analysis shows that student engagement and quiz work is a prominent learning solution for increasing motivation in and out of the classroom. We found that quizzes can be applied in software engineering and through generic quizzes, online Quizzes, pop-Quizzes, gamified Quizzes, in quiz games or, alternatively, as an exercise in creating quizzes. However, we did not find approaches to the use of quizzes, explicitly containing Zimmerman's cyclic model, only some of the model's activities in isolation and not explicitly. We argue that sharing the quizzes will raise the potential for then to be use as a self-regulation tool in software engineering education. We describe the steps taken by a Software Engineering Gamification project to create a effective tool for creating and sharing software engineering quizzes. Our next requirement to be implemented in the project will be the application of self-regulation of learning containing the three phases of the Zimermman cyclic model.

Few if any would dispute that educating software engineering is a challenging endeavour. Although programming and creating new artefacts can motivate the creativity of students. Other software engineering topics (like e.g. requirement specifications and testing) are not considered very exciting by students. However, these topics are important to develop quality software and insufficient knowledge of students - Europe's future software engineers - in the long run contributes to failing software. The EU Erasmus+ project IMPRESS was set to explore the use of gamification in educating software engineering at the university level. The objective has been to develop a toolset that can help to improve students' engagement, and hence their appreciation, for the taught subjects like software testing and specifications. The proposed tutorial will guide participants through the set of tools developed by the project and introduce how they can use them to improve students' engagement.

Monolith applications tend to be difficult to deploy, upgrade, maintain, and understand. Microservices, on the other hand, have the advantages of being independently developed, tested, deployed, scaled and, more importantly, easier to change and maintain. This paper addresses the problem of migrating a monolith to a microservices architecture. Therefore, we address two research questions: (1) Can we define the cost of decomposition in terms of the effort to redesign a functionality, which is implemented in the monolith as an ACID transaction, into several distributed transactions? (2) Considering several similarity measures between domain entities, which provide a better decomposition when they are compared using the proposed complexity metric? To answer the first research question, we propose a complexity metric, for each functionality of the monolith application, that measures the impact of relaxing the functionality consistency on the architecture redesign and implementation. Regarding the second research question, we experiment with four similarity measures, each based on a different type of information collected from monolith functionality implementation. We evaluated our approach with three monolith systems and compared our complexity metric against industry metrics of cohesion and coupling. We also evaluated the different similarity measures in terms of the complexity of the decomposition they produce. We were able to correctly correlate the complexity metric with other metrics of cohesion and coupling defined in other research and we conclude that no single combination of similarity measures outperforms the other, which is confirmed by the existing research. Additionally, we conclude that the approach can help on an incremental migration to microservices, which, actually, is the strategy proposed by the industry experts.

Merge conflicts cause software defects which if detected late may require expensive resolution. This is especially true when developers work too long without integrating concurrent changes, which in practice is common as integration generally occurs at check-in. Awareness of others' activities was proposed to help developers detect conflicts earlier. However, it requires developers to detect conflicts by themselves and may overload them with notifications, thus making detection harder. This paper presents a novel solution that continuously merges uncommitted and committed changes to create a background system that is analyzed, compiled, and tested to precisely and accurately detect conflicts on behalf of developers, before check-in. An empirical study confirms that our solution avoids overloading developers and improves early detection of conflicts over existing approaches. Similarly to what happened with continuous compilation, this introduces the case for continuous merging inside the IDE.

Abstract Business Process Management is called agile when it is able to react quickly and adequately to internal and external events. Agile Business Process Management requires putting the life cycle of business processes on a new paradigm. It is advocated in this paper that social software allows us to satisfy the key requirements for enabling agile BPM by applying the four features of social software: weak ties, social production, egalitarianism and mutual service provision. Organizational and semantic integration and responsiveness (of the business processes engineering, execution and management activities) have been identified as the main requirements for implementing an agile BPM life cycle. Social software may be used in the BPM life cycle in several manners and using numerous approaches. This paper presents seven among them and then analyzes the ‘support’ effects between those approaches and the underlying social software features, and the three requirements for Agile BPM. Copyright © 2011 John Wiley & Sons, Ltd.

Current best practices on web application development build on a plethora of design patterns, frameworks, and tools to support commontasks such as handling requests from the user and persisting domain entities: Even the simplest web applications need suchthings. Thus, web application developers are forced to learn anenormous amount of technology before they can start being productivein the development process.This paper proposes a simpler approach to the development of web applications, based on the combination of two elements. First, the use of Software Transactional Memory to bring the transactionsemantics into the programming language level. Second, we propose an object-oriented Domain Modeling Language to specify the domain model.This domain model is transformed into classes that haveinterfaces that an object-oriented programmer would expect, but the objects of these classes are transparently transactional andpersistent.This approach significantly reduces both the effort and the errorsmade during the development of new applications. Rather thandealing with multiple configuration files and tools, which have norelation to the domain problem, programmers can concentrate exclusively on an object-oriented model of the problem they want to solve. By using this approach, we can delay, or completely avoid,the commitment to a particular technology.

This paper describes an object-oriented abstraction for the problem of awareness management in Collaborative Virtual Environments (CVEs). The described abstraction allows for different types of awareness information and awareness management policies to be used. It is also described how the defined abstraction was used to support the awareness management policies of two demo CVEs application.

Naming is an important, but frequently overlooked, aspect of software systems. Naming is usually combined with other issues, e.g. distributed communication technology. The paper treats naming in isolation. It presents a naming design pattern which abstracts several naming policies and an object-oriented framework that can be customized to support naming policies. An applications designer can choose the correct naming properties (relative, absolute, universal identifiers, etc.) to refer to specific objects.

This paper introduces an object-oriented approach to the integrated modeling of organizations, and their information systems in a distributed context. The approach is based on the OOram role modeling methodology concepts and tool. In the proposed approach organization modeling is done at the enterprise level of abstraction and both reverse and forward engineering are consistently supported. Distribution is modeled, at both the organization and information system levels of abstraction, in an integrated way. Traceability is supported between all models.

We propose an object-oriented approach to the development of distributed applications emphasizing separation of concerns. Our approach combines the needs of transparency, encapsulation of distribution issues, and support for non-traditional models, where cooperation and sharing are desired. The development process is constructive, thus allowing partial verification of results. We recognize seven concerns: fragmentation, replication, naming, concurrency, failure, configuration, and communication. Each concern as perceived in three levels of abstraction: model, policy and mechanism. We also propose an integration process centered on development stages. Both concerns and stage perspectives are part of an integrated and flexible development process.