Abstract The rapid adoption of Artificial Intelligence (AI) and Generative AI (GenAI) tools is transforming the creation, maintenance, and dissemination of research software. Despite their growing prevalence, the implications of these technologies for Research Software Engineering (RSE) practices remain underexplored. This work introduces AI4RSE , an emerging research domain focused on the integration of AI into the development lifecycle of research software. To investigate current trends in AI-augmented RSE, we conducted an empirical study of more than 1,500 open-source research software repositories hosted on Zenodo. Each repository was assessed using a quadrant-based typology defined by two key dimensions: software engineering maturity and the level of AI integration. Our analysis combined static and semantic code inspection, evaluation of alignment with the FAIR Principles for Research Software (FAIR4RS), and heuristic classification of generative AI usage and MLOps adoption. Repositories are categorized into four development modes: Exploratory Coding , Vibe Coding , RSE , and AI4RSE , which reflect different levels of process rigor and AI tool integration. While many projects exhibit informal development patterns, a growing subset demonstrates mature, AI-assisted workflows. This landscape reveals key challenges, such as reproducibility risks and licensing ambiguity, while also highlighting emerging opportunities, including AI-assisted testing and intelligent documentation generation. The findings support a research agenda for AI4RSE, outlining benchmarks, guidelines, and community standards to promote responsible, reproducible, and scalable adoption of AI in scientific software development.

This study proposes Dynamic Warping (DW) as a sensor reconstruction method for Remaining Useful Life (RUL) estimation. The method utilizes the DW model for sensor reconstruction, where Median Absolute Deviation measures the reconstruction error, which is expected to increase when abnormal system behavior is measured. We apply an exponential model to the reconstruction error to estimate a system’s RUL. The DW model is based on the Dynamic Time Warping algorithm applied to a non-temporal context. The concept is to preprocess sensor data into a non-temporal motion profile representing a cycle. We validate our proposed DW model with two baseline models: Singular Value Decomposition (SVD) and LSTM Autoencoder (LSTM-AE). The SVD model is applied to the non-temporal motion profile, while the LSTM-AE model is applied to the original sensor data. A case study was conducted at a semiconductor Original Equipment Manufacturer, whose dataset contained information on a bearing failure in a water-cooled direct drive rotary motor. The failure occurred due to increased friction caused by bearing wear. The valuable motion control signal found was torque applied to the shaft for the R and S phases. It was demonstrated that the proposed method is most efficient, and an alarm can be raised 11 hours before failure, after which the RUL can be estimated, which is promising for warning service engineers for this industrial application. This research shows that the DW model could predict maintenance furthest in advance while only needing a fraction of the training data.

Abstract Microservice architecture (MSA) is an architectural style that is designed to support the modular development of software systems within a particular domain. It is characterized by the use of small, independently deployable services, which can be developed and deployed autonomously. The benefits of MSA include improved scalability, fault‐tolerance, and ease of deployment and maintenance. However, developing MSA for a specific domain can be challenging and requires a thorough consideration of various concerns such as service boundaries, communication protocols, and security. To support the easy development and guidance of an MSA for practitioners, we present a reference architecture design for MSA. The reference architecture has been designed after a comprehensive domain analysis of MSA in the literature and the MSAs of key vendors. This analysis has been used to identify best practices and common patterns that can be applied to the development of MSA. Additionally, relevant architecture viewpoints have been selected to model the corresponding architecture views, providing a clear and comprehensive understanding of the architecture. To validate the proposed reference architecture, a multi‐case study research approach has been used. In this approach, two industrial case studies have been used to demonstrate the practical applicability of the proposed reference architecture. The results of these case studies have shown that the reference architecture can be used to effectively guide the development of MSA in real‐world scenarios.

Summary Malicious software forms a threat to many software‐intensive systems and as such several malware detection approaches have been introduced, often based on sequential data analysis. Long short‐term memory (LSTM) is an artificial recurrent neural network (RNN) architecture that is effective for sequential data analysis, however, no study has yet analyzed the performance of different LSTM architectures for the application of malware detection. In this article, we aim to evaluate and benchmark the performance of LSTM‐based malware detection approaches on specific LSTM architectures to provide insight into malware detection. Our method builds LSTM‐based malware prediction models and performs experiments using different LSTM architectures including Vanilla LSTM, stacked LSTM, bi‐directional LSTM, and CNN‐LSTM. We evaluated the performance of each of these architectures and different configurations. Our study, as a contribution, shows that Bidirectional LSTM with hyperparameter optimization is found to be overperforming other selected LSTM architectures. This study shows that different LSTM approaches and architectures are applicable to the malware detection problem. Quality attributes such as efficiency and accuracy, and the software system architecture adopted for the implementation impact the selection of the LSTM approach.

With the current international shortage of speech-language pathologists (SLPs), there is a demand for online tools to support SLPs with their daily tasks. For this purpose, several online speech therapy systems (OSTSs) have been proposed and discussed in the literature. However, developing these OSTSs is not trivial since it involves the consideration of various functional and quality concerns. Hence, for communicating the design decisions and guiding the development and analysis of these systems, a proper architecture design is important. Unfortunately, the architecture design of OSTSs has not been explicitly addressed in the literature. To this end, we present a reference architecture for OSTSs which has been designed following well-established architecture design methods. The reference architecture captures the reusable design elements of OSTSs and can be used to derive various different application architectures. A case study approach is used to illustrate and validate the use of the presented reference architecture.

Recently pipelines of machine learning-based classification models have become important to codify, orchestrate, and automate the workflow to produce an effective machine learning model. In this article, we propose a framework that combines feature engineering techniques such as data imputation, transformation, and class balancing to compare the performance of different prediction models and select the best final model based on predefined parameters. The proposed framework is extendable and configurable by adding algorithms supported by the CARET package implemented in the R programming language. This framework can generate different machine learning models, which provide comparable results compared to other studies. The framework allows practitioners and researchers to automatically generate different classification models. This research used High-Resolution Orbitrap-based Mass Spectrometers (HRMS) data to create automated prediction models for the first time in literature. We demonstrated the applicability of feature engineering techniques such as data imputation, transformation (e.g., scaling, centering, etc.), and data balancing using several case studies and the proposed semi-automated framework. We showed how the initial prediction models can be improved using the proposed framework.

Automated software defect prediction (SDP) methods are increasingly applied, often with the use of machine learning (ML) techniques. Yet, the existing ML-based approaches require manually extracted features, which are cumbersome, time consuming and hardly capture the semantic information reported in bug reporting tools. Deep learning (DL) techniques provide practitioners with the opportunities to automatically extract and learn from more complex and high-dimensional data. The purpose of this study is to systematically identify, analyze, summarize, and synthesize the current state of the utilization of DL algorithms for SDP in the literature. We systematically selected a pool of 102 peer-reviewed studies and then conducted a quantitative and qualitative analysis using the data extracted from these studies. Main highlights include: (1) most studies applied supervised DL; (2) two third of the studies used metrics as an input to DL algorithms; (3) Convolutional Neural Network is the most frequently used DL algorithm. Based on our findings, we propose to (1) develop more comprehensive DL approaches that automatically capture the needed features; (2) use diverse software artifacts other than source code; (3) adopt data augmentation techniques to tackle the class imbalance problem; (4) publish replication packages.

Abstract Just-in-time defect prediction (JITDP) research is increasingly focused on program changes instead of complete program modules within the context of continuous integration and continuous testing paradigm. Traditional machine learning-based defect prediction models have been built since the early 2000s, and recently, deep learning-based models have been designed and implemented. While deep learning (DL) algorithms can provide state-of-the-art performance in many application domains, they should be carefully selected and designed for a software engineering problem. In this research, we evaluate the performance of traditional machine learning algorithms and data sampling techniques for JITDP problems and compare the model performance with the performance of a DL-based prediction model. Experimental results demonstrated that DL algorithms leveraging sampling methods perform significantly worse than the decision tree-based ensemble method. The XGBoost-based model appears to be 116 times faster than the multilayer perceptron-based (MLP) prediction model. This study indicates that DL-based models are not always the optimal solution for software defect prediction, and thus, shallow, traditional machine learning can be preferred because of better performance in terms of accuracy and time parameters.

Predictive maintenance is a technique for creating a more sustainable, safe, and profitable industry. One of the key challenges for creating predictive maintenance systems is the lack of failure data, as the machine is frequently repaired before failure. Digital Twins provide a real-time representation of the physical machine and generate data, such as asset degradation, which the predictive maintenance algorithm can use. Since 2018, scientific literature on the utilization of Digital Twins for predictive maintenance has accelerated, indicating the need for a thorough review. This research aims to gather and synthesize the studies that focus on predictive maintenance using Digital Twins to pave the way for further research. A systematic literature review (SLR) using an active learning tool is conducted on published primary studies on predictive maintenance using Digital Twins, in which 42 primary studies have been analyzed. This SLR identifies several aspects of predictive maintenance using Digital Twins, including the objectives, application domains, Digital Twin platforms, Digital Twin representation types, approaches, abstraction levels, design patterns, communication protocols, twinning parameters, and challenges and solution directions. These results contribute to a Software Engineering approach for developing predictive maintenance using Digital Twins in academics and the industry. This study is the first SLR in predictive maintenance using Digital Twins. We answer key questions for designing a successful predictive maintenance model leveraging Digital Twins. We found that to this day, computational burden, data variety, and complexity of models, assets, or components are the key challenges in designing these models.

The article presents the results of a Systematic Literature Review (SLR) that has been carried out to identify and present the state-of-the-art of ERP systems, describe the obstacles of on-premise ERP systems, and provide general solutions to tackle these challenges. Based on this SLR, 22 obstacles are identified, the dependencies and interactions among these obstacles are described, and finally the corresponding solutions as described in the primary studies are discussed in detail. Our study shows that there is a general agreement on the obstacles of on-premise ERP systems and further research is needed to provide satisfactory solutions to the obstacles.

Abstract Microservice architecture (MSA) is a paradigm to design and develop scalable distributed applications using loosely coupled, highly cohesive components that can be deployed independently. The applications that realize the MSA may contain thousands of services that together form the overall system. Microservices interact with each other by producing and consuming data. Deploying frequently communicating services to the same physical resource would reduce network utilization, which is vital for reducing costs and improving scalability. Since the physical resources have limited capacity, it is not always possible to deploy communicating services to the same resource. Therefore, automated efficient deployment alternatives need to be generated for MSA in the design phase. To address this problem, we proposed an algorithmic approach to generate efficient microservice deployment configurations to available cloud resources in our previous study. In this study, a tool (Micro‐IDE) has been proposed to realize and evaluate this approach. The Micro‐IDE tool has been validated using a case study inspired by the Spotify application.

One of the key challenges in computer networks is network security. For securing the network, various solutions have been proposed, including network security protocols and firewalls. In the case of so-called packet-filtering firewalls, policy rules are implemented to monitor changes to the network and preserve the required security level. Due to the dramatic increase of devices, however, and herewith the rapid increase of the size of the policy rules, firewall policy anomalies occur more frequently. This requires careful implementation of the policy rules to ensure cost-efficient solutions for anomaly detection to support network security. In this study, we present an anomaly detection framework for detecting intrafirewall policy anomaly rules. The framework supports the simulation of packets through the firewall ruleset for validating and enhancing the security level of the network. The framework is validated using four different types of firewall policy anomalies. Experimental results demonstrate that the framework is effective and efficient in detecting firewall policy anomalies.

Abstract Cybersecurity is critical in realizing Internet of Things (IoT) applications and many different standards have been introduced specifically for this purpose. However, selecting relevant standards is not trivial and requires a broad understanding of cybersecurity and knowledge about the available standards. In this study, we present a systematic approach that guides IoT system developers in selecting relevant cybersecurity standards for their IoT projects. The systematic approach has been developed in four stages. First, the common and variant features of IoT cybersecurity have been modeled using a feature model. Second, an up‐to‐date overview of the IoT cybersecurity standards landscape has been mapped by combining existing overviews. Third, a text mining algorithm has been implemented. Fourth, the systematic approach has been modeled using business process modeling notation. Our case study demonstrated that this approach is effective and efficient for guiding the selection of IoT cybersecurity standards.

The systematic literature review (SLR) process includes several steps to collect secondary data and analyze it to answer research questions. In this context, the document retrieval and primary study selection steps are heavily intertwined and known for their repetitiveness, high human workload, and difficulty identifying all relevant literature. This study aims to reduce human workload and error of the document retrieval and primary study selection processes using a decision support system (DSS). An open-source DSS is proposed that supports the document retrieval step, dataset preprocessing, and citation classification. The DSS is domain-independent, as it has proven to carefully select an article’s relevance based solely on the title and abstract. These features can be consistently retrieved from scientific database APIs. Additionally, the DSS is designed to run in the cloud without any required programming knowledge for reviewers. A Multi-Channel CNN architecture is implemented to support the citation screening process. With the provided DSS, reviewers can fill in their search strategy and manually label only a subset of the citations. The remaining unlabeled citations are automatically classified and sorted based on probability. It was shown that for four out of five review datasets, the DSS's use achieved significant workload savings of at least 10%. The cross-validation results show that the system provides consistent results up to 88.3% of work saved during citation screening. In two cases, our model yielded a better performance over the benchmark review datasets. As such, the proposed approach can assist the development of systematic literature reviews independent of the domain. The proposed DSS is effective and can substantially decrease the document retrieval and citation screening steps' workload and error rate.

Research collaboration between industry and academia supports improvement and innovation in industry and helps ensure the industrial relevance of academic research. However, many researchers and practitioners in the community believe that the level of joint industry-academia collaboration (IAC) projects in Software Engineering (SE) research is relatively low, creating a barrier between research and practice. The goal of the empirical study reported in this paper is to explore and characterize the state of IAC with respect to industrial needs, developed solutions, impacts of the projects and also a set of challenges, patterns and anti-patterns identified by a recent Systematic Literature Review (SLR) study. To address the above goal, we conducted an opinion survey among researchers and practitioners with respect to their experience in IAC. Our dataset includes 101 data points from IAC projects conducted in 21 different countries. Our findings include: (1) the most popular topics of the IAC projects, in the dataset, are: software testing, quality, process, and project managements; (2) over 90% of IAC projects result in at least one publication; (3) almost 50% of IACs are initiated by industry, busting the myth that industry tends to avoid IACs; and (4) 61% of the IAC projects report having a positive impact on their industrial context, while 31% report no noticeable impacts or were “not sure”. To improve this situation, we present evidence-based recommendations to increase the success of IAC projects, such as the importance of testing pilot solutions before using them in industry. This study aims to contribute to the body of evidence in the area of IAC, and benefit researchers and practitioners. Using the data and evidence presented in this paper, they can conduct more successful IAC projects in SE by being aware of the challenges and how to overcome them, by applying best practices (patterns), and by preventing anti-patterns.

Abstract Software vulnerabilities form an increasing security risk for software systems, that might be exploited to attack and harm the system. Some of the security vulnerabilities can be detected by static analysis tools and penetration testing, but usually, these suffer from relatively high false positive rates. Software vulnerability prediction (SVP) models can be used to categorize software components into vulnerable and neutral components before the software testing phase and likewise increase the efficiency and effectiveness of the overall verification process. The performance of a vulnerability prediction model is usually affected by the adopted classification algorithm, the adopted features, and data balancing approaches. In this study, we empirically investigate the effect of these factors on the performance of SVP models. Our experiments consist of four data balancing methods, seven classification algorithms, and three feature types. The experimental results show that data balancing methods are effective for highly unbalanced datasets, text‐based features are more useful, and ensemble‐based classifiers provide mostly better results. For smaller datasets, Random Forest algorithm provides the best performance and for the larger datasets, RusboostTree achieves better performance.

An important challenge in parallel computing is the mapping of parallel algorithms to parallel computing platforms. This requires several activities such as the analysis of the parallel algorithm, the definition of the logical configuration of the platform and the implementation and deployment of the algorithm to the computing platform. However, in current parallel computing approaches very often only conceptual and idiosyncratic models are used which fall short in supporting the communication and analysis of the design decisions. In this article, we present ParDSL, a domain-specific language framework for providing explicit models to support the activities for mapping parallel algorithms to parallel computing platforms. The language framework includes four coherent set of domain-specific languages each of which focuses on an activity of the mapping process. We use the domain-specific languages for modeling the design as well as for generating the required platform-specific models and the code of the selected parallel algorithm. In addition to the languages, a library is defined to support systematic reuse. We discuss the overall architecture of the language framework, the separate DSLs, the corresponding model transformations and the toolset. The framework is illustrated for four different parallel computing algorithms.

Summary Context: The architectural drift problem defines the discrepancy between the architecture description and the code. Deviations of the code from the architecture can occur if architectural constraints as defined in the architectural models are not implemented in the code. For large‐scale systems, manually checking the consistency of the architecture with the code is not trivial and cumbersome. Objective: The overall objective of this paper is to propose and analyze the effectiveness and practicality of an architecture conformance analysis approach using model‐based testing (ACAMBT) approach for checking the consistency between architectural models and the code. Hereby, we consider the case whereby the architecture is assumed correct, and the code needs to align with the architecture. Method: We propose a model‐based testing that uses architectural views to automatically derive test cases for checking the architectural constraints in the code. We have evaluated the approach and the corresponding toolset for a real industrial case study using a systematic case study protocol. Further, we have adopted exhaustive fault‐injection techniques to detect the constraint violations. Results: The evaluation of the approach on real code showed that deviations with the architectural constraints could be easily detected in the code. Conclusion: We can conclude that ACAMBT is effective for identifying inconsistencies between the architecture views and the code for the defined view constraints. Our survey study with practitioners showed that adopting the ACAMBT approach is practical and easy to use. The approach as such can be considered as a complimentary tool to the existing testing and reflexion modeling approaches.

Model Driven Architecture Based Testing (MDABT) is a testing approach exploiting the knowledge in the design phase to test the software system. MBT can use different representations of the system to generate testing procedures for different aspects of the software systems. The overall objective of this paper is to present a model-driven architecture based testing tool framework whereby the adopted models represent models of the architecture. Based on the model-based testing approach we propose the MDABT process and the corresponding tool. The tool has been implemented using the Eclipse Epsilon Framework. We illustrate the MDABT tool framework for deriving test cases from different architecture views.

We present AlloyInEcore, a tool for specifying metamodels with their static semantics to facilitate automated, formal reasoning on models. Software development projects require that software systems be specified in various models (e.g., requirements models, architecture models, test models, and source code). It is crucial to reason about those models to ensure the correct and complete system specifications. AlloyInEcore~allows the user to specify metamodels with their static semantics, while, using the semantics, it automatically detects inconsistent models, and completes partial models. It has been evaluated on three industrial case studies in the automotive domain (https://modelwriter.github.io/AlloyInEcore/).

The results of a systematic literature review conducted for variability modelling in software component models are analysed and presented here. A well‐planned protocol guided the screening of 3230 papers that resulted in the identification of 55 papers. Reviewing these papers, 23 of them were considered as primary studies related to our research questions. A comparison framework is introduced to further understand, assess, and compare those selected papers. Observations about the important aspects of component models that support the variability capability are summarised. Prominent trends and approaches are discussed along with a comparative analysis of the component models. Only a few component models were found to be explicitly accommodating variability concerns. The identified variability modelling problems require further research for attaining better reuse capabilities.

Testing safety-critical systems is crucial since a failure or malfunction may result in death or serious injuries to people, equipment, or environment. An important challenge in testing is the derivation of test cases that can identify the potential faults. Model-based testing adopts models of a system under test and/or its environment to derive test artifacts. This paper aims to provide a systematic mapping study to identify, analyze, and describe the state-of-the-art advances in model-based testing for software safety. The systematic mapping study is conducted as a multi-phase study selection process using the published literature in major software engineering journals and conference proceedings. We reviewed 751 papers and 36 of them have been selected as primary studies to answer our research questions. Based on the analysis of the data extraction process, we discuss the primary trends and approaches and present the identified obstacles. This study shows that model-based testing can provide important benefits for software safety testing. Several solution directions have been identified, but further research is critical for reliable model-based testing approach for safety.

Current big data cloud systems often use different data migration strategies from providers to customers. This often results in increased bandwidth usage and herewith a decrease of the performance. To enhance the performance often caching mechanisms are adopted. However, the implementations of these caching mechanisms are often dedicated solutions for specific applications and/or use case scenarios. The adoption of different caching implementations within the same system leads to different problems including increased maintenance overhead, decrease of reuse, reduced adaptability, and resource allocation problems. To overcome these problems, in this paper we propose the so-called OneService Framework, which provides a generic cache aggregator mechanism that can be used with different cache storages to fetch and distribute the data from various providers. The framework as such helps to increase reuse, support adaptability, resolve the resource allocation problems, and enhance the overall performance of the system. We discuss the overall design of the framework together with the basic implementation concerns. The framework is illustrated for analyzing the maintenance, reusability and cost of MSN backend services.

The ModelWriter platform provides a generic framework for automated traceability analysis. In this paper, we demonstrate how this framework can be used to trace the consistency and completeness of technical documents that consist of a set of System Installation Design Principles used by Airbus to ensure the correctness of aircraft system installation. We show in particular, how the platform allows the integration of two types of reasoning: reasoning about the meaning of text using semantic parsing and description logic theorem proving; and reasoning about document structure using first-order relational logic and finite model finding for traceability analysis.

We present Tarski, a tool for specifying configurable trace semantics to facilitate automated reasoning about traces. Software development projects require that various types of traces be modeled between and within development artifacts. For any given artifact (e.g., requirements, architecture models and source code), Tarski allows the user to specify new trace types and their configurable semantics, while, using the semantics, it automatically infers new traces based on existing traces provided by the user, and checks the consistency of traces. It has been evaluated on three industrial case studies in the automotive domain (https://modelwriter.github.io/Tarski/).

Summary The need for high‐performance computing together with the increasing trend from single processor to parallel computer architectures has leveraged the adoption of parallel computing. To benefit from parallel computing power, usually parallel algorithms are defined that can be mapped and executed on parallel computing platforms. In general, different alternative mappings can be defined each with different performance. For small computing platforms with a limited number of processing nodes, the mapping process can be carried out manually. However, for large‐scale parallel computing platforms in which hundreds of thousands of processing nodes are applied, the number of possible mapping alternatives increases dramatically, and the mapping process becomes intractable for the human engineer. To assist the parallel computing engineer, we provide a systematic approach to derive feasible mapping alternatives of parallel algorithms to parallel computing platforms. The approach includes activities for modeling the parallel algorithm and parallel computing platform, generation of feasible mapping alternatives, generation of the deployment code, and finally the deployment of the generated code to the nodes. We evaluate our approach for deriving feasible mapping alternatives for four well‐known parallel algorithms. The evaluation is based on both simulations and real executions of the generated mapping alternatives. Copyright © 2016 John Wiley & Sons, Ltd.

Currently, many organizations need to collaborate to achieve their common objectives. An important aspect hereby is the data required for making decisions at anyone organization may be distributed over the different organizations involved in the collaboration. The data objects and the activities in which they are generated or used are typically represented using business process models. Unfortunately, the existing business process modeling approaches are limited in representing the complex data allocation dimensions that occur in the context of multi-organization collaboration. In this paper we provide a systematic approach that adopts workflow data patterns to explicitly model data allocations in multi-organization collaboration. To this end we propose a design viewpoint that integrates business process models with well-known data allocation problem-solution pairs defined as workflow data patterns. We illustrate the viewpoint using a case study of a collaboration research project.ISBN: 978-989-758-193-9

Mapping parallel algorithms to parallel computing platforms requires several activities such as the analysis of the parallel algorithm, the definition of the logical configuration of the platform, the mapping of the algorithm to the logical configuration platform and the implementation of the source code. Applying this process from scratch for each parallel algorithm is usually time consuming and cumbersome. Moreover, for large platforms this overall process becomes intractable for the human engineer. To support systematic reuse we propose to adopt a model-driven product line engineering approach for mapping parallel algorithms to parallel computing platforms. Using model-driven transformation patterns we support the generation of logical configurations of the computing platform and the generation of the parallel source code that runs on the parallel computing platform nodes. The overall approach is illustrated for mapping an example parallel algorithm to parallel computing platforms.

Two important trends can be identified in parallel computing. First of all, the scale of parallel computing platforms is rapidly increasing. Secondly, the complexity and variety of current software systems requires to consider the parallelization of application modules beyond algorithms. These two trends have led to a complexity that is not scalable and tractable anymore for manual processing, and therefore automated support is required to design and implement parallel applications. In this context, we present a model-driven transformation chain for supporting the automation of the lifecycle of parallel computing applications. The model-driven transformation chain adopts metamodels that are derived from architectural viewpoints. Thetransformation chain is defined as a logical sequence consisting of model-to-model transformations. We present the tool support that implements the metamodels and transformations.

To increase the computing performance the current trend is towards applying parallel computing in which the tasks are run in parallel on multiple nodes. Current approaches in parallel computing tend to focus on mapping parallel algorithms to parallel computing platforms. However, the complexity and variety of current software systems goes beyond the notion of algorithms only, and needs to consider the design from a broader application perspective that requires explicit design abstractions. For this purpose, we propose an architecture framework for modeling parallel applications to support the communication among the stakeholders, to reason about the design decisions and to support the analysis of the architectural design. The architecture framework consists of six coherent set of viewpoints which addresses different concerns in the design of parallel applications. The architecture framework is based on a metamodel that is derived after a thorough domain analysis on parallel computing. To support the architecture design process we have also developed the corresponding tool set that implements the architecture framework. The application of the architecture framework is illustrated for an order management application.

In an industrial context, software systems are rarely developed by a single organization. For software product lines, this means that various organizations collaborate to provide and integrate the assets used in a product line. It is not uncommon that these assets themselves are built as product lines, a practice which is referred to as multi product lines. This cross-organizational distribution of reusable assets leads to numerous challenges, such as inconsistent configuration, costly and time-consuming integration, diverging evolution speed and direction, and inadequate testing.

In practice, inconsistencies between architectural documentation and the code might arise due to improper implementation of the architecture or the separate, uncontrolled evolution of the code. Several approaches have been proposed to detect inconsistencies between the architecture and the code but these tend to be limited for capturing inconsistencies that might occur at runtime. We present a runtime verification approach for detecting inconsistencies between the dynamic behavior of the documented architecture and the actual runtime behavior of the system. The approach is supported by a set of tools that implement the architecture and the code patterns in Prolog, and automatically generate runtime monitors for detecting inconsistencies. We illustrate the approach and the toolset for a Crisis Management System case study.

In the global context, the software sector has gained importance and this trend seems to continue in many countries including Turkey. There are more than 35 large companies operating in the software market in Turkey. The quality of Turkish software companies is increasing each year. A growing number of software companies have obtained at least the CMMI level 3 rating. Over the last years, Turkish software companies have also started to export software to almost 70 countries.

In order to meet the communication, coordination and control requirements of distributed Global Software Development (GSD) teams, it is necessary to define a proper software architecture. Designing a GSD architecture, however, involves a multitude of design decisions that are related in different ways. As such, it is not trivial for the architect to design a system that meets the different GSD concerns. To assist the architect in designing a suitable GSD architecture we propose the tool framework Global Architect. The tool framework is based on a common meta-model for GSD and a question framework, which includes a predefined set of questions that are related to abstract design rules for designing GSD systems. Based on the answers provided to the questions of the question framework, the tool automatically selects and instantiates the necessary rules and generates the GSD architecture. Global Architect has been applied to design the GSD architecture for a real industrial project of Cybersoft, a leading GSD company in Turkey.

Each software architecture design is the result of a broad set of design decisions and their justifications, that is, the design rationale. Capturing the design rationale is important for a variety of reasons such as enhancing communication, reuse and maintenance. Unfortunately, it appears that there is still a lack of appropriate methods and tools for effectively capturing and managing the architecture design rationale. In this paper we present a feature-based rationale management approach and the corresponding tool environment ArchiRationale for supporting software architecture adaptation. The approach takes as input an existing architecture and captures the design rationale for adapting the architecture for a given quality concern. For this we define a feature model that includes the possible set of architectural tactics to realize the quality concern. The presented approach captures the rationale for deciding on feature selections and for selecting the corresponding architecture design alternatives. ArchiRationale customizes and integrates the Eclipse plugin tools XFeature, ArchStudio and XQuery to provide tool support for capturing, storing and accessing the design rationale. We illustrate the approach for adapting a software architecture for fault tolerance.

Currently, a common practice is to model and document architecture based on architectural views. Architectural views conform to viewpoints that represent the conventions for constructing and using architecture views. So far most architecture viewpoints seem to have been primarily used either to support the communication among stakeholders, or at the best to provide a blueprint for the detailed design. In this paper we introduce the eclipse plug-in tool, Software Architecture Environment for modeling Views (SAVE) tool that can be used to model software architecture based on viewpoints from existing viewpoint approaches. In the tool each viewpoint is modeled as a domain specific language which increases the formal precision of the derived views and as such enables model-driven development.

This paper summarizes the workshop on Architecture-Based Testing and System Validation which was organized in conjunction with the 9th Working IEEE/IFIP Conference on Software Architecture. The main goal of the workshop was to bring together researchers and practitioners both from the architecture design and software testing community to enable architecture-based software testing.

In general, a common reference architecture can be derived for Software as a Service (SaaS). However, while designing particular applications one may derive various application design alternatives from the same reference SaaS architecture specification. To meet the required functional and nonfunctional requirements of different enterprise applications it is important to model the possible design so that a feasible alternative can be defined. In this paper, we propose a systematic approach and corresponding tool support for guiding the design of SaaS application architectures. The approach defines a SaaS reference architecture, a family feature model and a set of reference design rules. Based on the business requirements an application feature model is defined using the family feature model. Selected features are related to design decisions and a SaaS application architecture design is derived.

Abstract The decomposition of software architecture into modular units is usually driven by the required quality concerns. In this paper we focus on the impact of local recovery concern on the decomposition of the software system. For achieving local recovery, the system needs to be decomposed into separate units that can be recovered in isolation. However, it appears that this required decomposition for recovery is usually not aligned with the decomposition based on functional concerns. Moreover, introducing local recovery to a software system, while preserving the existing decomposition, is not trivial and requires substantial development and maintenance effort. To reduce this effort we propose a framework that supports the decomposition and implementation of software architecture for local recovery. The framework provides reusable abstractions for defining recoverable units and the necessary coordination and communication protocols for recovery. We discuss our experiences in the application and evaluation of the framework for introducing local recovery to the open‐source media player called MPlayer. Copyright © 2009 John Wiley & Sons, Ltd.

Early aspects deal with crosscutting concerns in requirements analysis, domain analysis and architecture design [1]. Work on early aspects focuses on systematically identifying, modularizing, and analyzing such crosscutting concerns and their impact at the early phases of the software development life cycle.

An analysis of the current practice for representing architectural views reveals that they focus mainly on functional concerns and are limited when considering quality concerns. We introduce the recovery style for modeling the structure of the system related to the recovery concern. The recovery style is a specialization of the module viewtype in the Views&Beyond approach. It is used to communicate and analyze architectural design decisions and to support detailed design with respect to recovery. We illustrate the style for modeling the recovery views for the open-source software, MPlayer.

We propose a Software Architecture Reliability Analysis (SARA) approach that benefits from both reliability engineering and scenario-based software architecture analysis to provide an early reliability analysis of the software architecture. SARA makes use of failure scenarios that are prioritized with respect to the user-perception in order to provide a severity analysis for the software architecture and the individual components.

Software architecture analysis methods aim to predict the quality of a system before it has been developed. In general, the quality of the architecture is validated by analyzing the impact of predefined scenarios on architectural components. Hereby, it is implicitly assumed that an appropriate refactoring of the architecture design can help in coping with critical scenarios and mending the architecture. This paper shows that there are also concerns at the architecture design level which inherently crosscut multiple architectural components, which cannot be localized in one architectural component and which, as such, can not be easily managed by using conventional abstraction mechanisms. We propose the aspectual software architecture analysis method (ASAAM) to explicitly identify and specify these architectural aspects and make them transparent early in the software development life cycle. ASAAM introduces a set of heuristic rules that help to derive architectural aspects and the corresponding tangled architectural components from scenarios. The approach is illustrated for architectural aspect identification in the architecture design of a window management system.

Software is rarely designed for ultimate adaptability, performance or reusability but rather it is a compromise of multiple considerations. Even for a simple architecture specification, one may identify many alternative implementations. The paper makes an attempt to depict the space of implementation alternatives of architectures, and to define rules for selecting them. The applicability of this approach is illustrated by means of a simple design problem.