Refine
Document Type
- Conference proceeding (8)
- Journal article (2)
Language
- English (10)
Has full text
- yes (10)
Is part of the Bibliography
- yes (10)
Institute
- Informatik (10)
Publisher
- Association for Computing Machinery (4)
- IEEE (2)
- Springer (2)
- Gesellschaft für Informatik e.V (1)
- RWTH Aachen (1)
Applications often need to be deployed in different variants due to different customer requirements. However, since modern applications often need to be deployed using multiple deployment technologies in combination, such as Ansible and Terraform, the deployment variability must be considered in a holistic way. To tackle this, we previously developed Variability4TOSCA and the prototype OpenTOSCA Vintner, which is a TOSCA preprocessing and management layer that implements Variability4TOSCA. In this demonstration, we present a detailed case study that shows how to model a deployment using Variability4TOSCA, how to resolve the variability using Vintner, and how the result can be deployed.
Application systems often need to be deployed in different variants if requirements that influence their implementation, hosting, and configuration differ between customers. Therefore, deployment technologies, such as Ansible or Terraform, support a certain degree of variability modeling. Besides, modern application systems typically consist of various software components deployed using multiple deployment technologies that only support their proprietary, non-interoperable variability modeling concepts. The Variable Deployment Metamodel (VDMM) manages the deployment variability across heterogeneous deployment technologies based on a single variable deployment model. However, VDMM currently only supports modeling conditional components and their relations which is sometimes too coarse-grained since it requires modeling entire components, including their implementation and deployment configuration for each different component variant. Therefore, we extend VDMM by a more fine-grained approach for managing the variability of component implementations and their deployment configurations, e.g., if a cheap version of a SaaS deployment provides only a community edition of the software and not the enterprise edition, which has additional analytical reporting functionalities built-in. We show that our extended VDMM can be used to realize variable deployments across different individual deployment technologies using a case study and our prototype OpenTOSCA Vintner.
Gamification has been increasingly applied to software engineering education in the past. The approaches vary from applying game elements on a conceptual phase in the course to using specific tools to engage the students more and support their learning goals. However, existing tools usually have game elements, such as quizzes or challenges, but do not provide a more computer game-like experience. Therefore, we try to raise the level of gamified learning experience to another level by proposing Gamify-IT. Gamify-IT is a Unity- and web-based game platform intended to help students learn software engineering. It follows an immersive role-play game characteristic where the students explore a world, find and solve minigames and clear dungeons with SE tasks. Lecturers can configure the worlds, e.g., to add content hints. Furthermore, they can add and configure minigames and dungeons to include exercises in a fully gamified way. Thereby, they customize their course in Gamify-IT to adapt the world very precisely to other materials such as lectures or exercises. Results of an evaluation of our initial prototype show that (i) students like to engage with the platform, (ii) students are motivated to learn when using Gamify-IT, and (iii) the minigames support students in understanding the learning objectives.
The introduction of smart contracts has expanded the applicability of blockchains to many domains beyond finance and cryptocurrencies. Moreover, different blockchain technologies have evolved that target special requirements. As a result, in practice, often a combination of different blockchain systems is required to achieve an overall goal. However, due to the heterogeneity of blockchain protocols, the execution of distributed business transactions that span several blockchains leads to multiple interoperability and integration challenges. Therefore, in this article, we examine the domain of Cross-Chain Smart Contract Invocations (CCSCIs), which are distributed transactions that involve the invocation of smart contracts hosted on two or more blockchain systems. We conduct a systematic multi-vocal literature review to get an overview of the available CCSCI approaches. We select 20 formal literature studies and 13 high-quality gray literature studies, extract data from them, and analyze it to derive the CCSCI Classification Framework. With the help of the framework, we group the approaches into two categories and eight subcategories. The approaches differ in multiple characteristics, e.g., the mechanisms they follow, and the capabilities and transaction processing semantics they offer. Our analysis indicates that all approaches suffer from obstacles that complicate real-world adoption, such as the low support for handling heterogeneity and the need for trusted third parties.
Blockchains have become increasingly important in recent years and have expanded their applicability to many domains beyond finance and cryptocurrencies. This adoption has particularly increased with the introduction of smart contracts, which are immutable, user-defined programs directly deployed on blockchain networks. However, many scenarios require business transactions to simultaneously access smart contracts on multiple, possibly heterogeneous blockchain networks while ensuring the atomicity and isolation of these transactions, which is not natively supported by current blockchain systems. Therefore, in this work, we introduce the Transactional Cross-Chain Smart Contract Invocation (TCCSCI) approach that supports such distributed business transactions while ensuring their global atomicity and serializability. The approach introduces the concept of Resource Manager Smart Contracts, and 2PC for Blockchains (2PC4BC), a client-driven Atomic Commit Protocol (ACP) specialized for blockchain-based distributed transactions. We validate our approach using a prototypical implementation, evaluate its introduced overhead, and prove its correctness.
Intelligent Tutoring Systems (ITSs) are increasingly used in modern education to automatically give students individual feedback on their performance. The advantage for students is fast individual feedback on their answers to asked questions, while lecturers benefit from considerable time savings and easy delivery of educational material. Of course, it is important that the provided feedback is as effective as direct feedback from the lecturer. However, in digital teaching, lecturers cannot assess the student’s knowledge precisely but can only provide information on which questions were answered correctly and incorrectly. Therefore, this paper presents a concept for integrating ITS elements into the gamified e-learning platform IT-REX so that the feedback quality can be improved to support students in the best possible way.
Modern component-based architectural styles, e.g., microservices, enable developing the components independently from each other. However, this independence can result in problems when it comes to managing issues, such as bugs, as developer teams can freely choose their technology stacks, such as issue management systems (IMSs), e.g., Jira, GitHub, or Redmine. In the case of a microservice architecture, if an issue of a downstream microservice depends on an issue of an upstream microservice, this must be both identified and communicated, and the downstream service’s issues should link to its causing issue. However, agile project management today requires efficient communication, which is why more and more teams are communicating through comments in the issues themselves. Unfortunately, IMSs are not integrated with each other, thus, semantically linking these issues is not supported, and identifying such issue dependencies from different IMSs is time-consuming and requires manual searching in multiple IMS technologies. This results in many context switches and prevents developers from being focused and getting things done. Therefore, in this paper, we present a concept for seamlessly integrating different IMS technologies into each other and providing a better architectural context. The concept is based on augmenting the websites of issue management systems through a browser extension. We validate the approach with a prototypical implementation for the Chrome browser. For evaluation, we conducted expert interviews, which approved that the presented approach provides significant advantages for managing issues of agile microservice architectures.
Modern software systems often consist of independently developed components, e.g., libraries or (micro-)services, that can be combined to form a larger architecture. Many of these components are developed externally, i.e., in other projects by other teams, which is particularly the case in service-oriented architectures. Even though the components are independently developed, bugs may arise that propagate along the call chains, which sometimes negatively affect the calling components. However, as such components are typically managed in separate issue management systems (IMS), identifying that a downstream component is affected by an upstream component’s issues is complex and time-consuming. Even though some scientific works and IMS forums discuss how to manage such cross-component issues, there is no systematic study on the state of practice and the challenges of issue management when different components are affected. Therefore, this study aims to determine which types of components are usually included in modern software projects, how developers identify and manage issue propagation between components, and how often they face such propagations. To get these insights, we conducted an empirical study through a questionnaire with 64 industry experts and open-source contributors and interviewed seven of them. Our key takeaways help researchers and software engineers to understand possible impacts and to improve cross-component issue management. We identified, for example, that related issues currently are non-semantically linked via URLs in issue comments.
Unveiling hurdles in software engineering education : the role of learning management systems
(2024)
Learning management systems (LMSs) are established tools in higher education, especially in the field of software engineering (SE). The onset of the COVID-19 pandemic further amplified the utilization of these systems, which necessitated their integration into educational curricula for both lecturers and students. However, adopting LMSs within SE education has presented distinctive challenges impeding their seamless incorporation into the courses. This paper aims to scrutinize the challenges and requirements encountered by professors, lecturers, and students in the domain of SE education when using LMSs. We conducted an empirical study that included (i) a survey with 47 professors/lecturers and 133 students, (ii) an analysis of the ensuing data, and (iii) 18 additional interviews conducted with professors and lecturers to delve into nuanced variations in viewpoints. The findings derived from our study reveal that the challenges and requirements pertaining to LMSs are rather specific depending on the scope and size of the respective courses. Nevertheless, many participants have a consensus on numerous challenges and requirements for improving certain features of LMSs in order to improve their usage in SE education. The findings are valuable for advancing research and development in the field of LMSs and provide guidance for lecturers in SE education.
The manual deployment of applications distributed across the cloud, fog, and edge is error-prone and complex. TOSCA is a standard for modeling the deployment of cloud applications in a vendor-neutral and technology-independent manner that is also suitable for the fog and edge continuum. However, there exist various TOSCA orchestrators with different functionalities. Thus, selecting an appropriate TOSCA orchestrator requires technical expertise since all the available orchestrators must be analyzed regarding technical, functional, legal, and organizational requirements. In this paper, we tackle this issue and present a systematic technology review of TOSCA orchestrators. Our goal is to support project managers, developers, and researchers in selecting a suitable TOSCA orchestrator. For this, we select actively maintained general-purpose open-source TOSCA orchestrators. Moreover, we introduce the TOSCA Orchestrator Classification Framework and present a selection support system.