Emotions play a critical role in shaping user experiences with interactive technologies, yet the HCI field has lacked a comprehensive, validated framework that captures the full spectrum of user affective states. This study addresses that gap by developing a PAD (Pleasure–Arousal–Dominance) model–based taxonomy specifically designed for human–computer interaction. Using a rigorous multi-stage methodology, the research synthesized findings from a systematic mapping of over 100 user emotions in the HCI literature, identifying 21 core emotional states based on frequency, relevance, and generalizability. A Delphi expert review refined the set, while each emotion was assigned PAD dimensional values ranging from –1 to 1. User studies in healthcare and gaming contexts validated the taxonomy’s ability to represent emotional trajectories, with new transitions informing iterative improvements. By integrating data-driven synthesis, expert consensus, and user-centered evaluation, this research delivers an evidence-based taxonomy to guide the engineering of emotionally aware interactive systems.

ABSTRACT Cybersecurity is a critical component of digital transformation, as the two must be integrated to enable business modernization and the adoption of innovative technologies while ensuring system security. Modern technologies introduce increasingly complex threats as more data is stored, transmitted, and processed across systems. Threats include the violation or misuse of data, such as data corruption, data theft, or a privacy violation. Determining if an organization applies the best practices requires measurements using maturity models. Several maturity models with different goals and qualities have been developed. However, no cybersecurity maturity model is related to digitally enabled or transforming organizations. The objective of this study is to develop a model that measures cybersecurity maturity for digitally transformed organizations. The model aims to provide a customizable assessment method for organizations of different sizes and domains. Two multivocal literature reviews (MLRs) were conducted to identify the available maturity models and best practices from formal and grey literature. After analyzing 165 studies, seven cybersecurity categories, as the capability areas, and 22 practice areas, were identified. Moreover, an assessment tool that supports self‐assessment was developed. Finally, the model was evaluated through five case studies and expert judgments. As a result, a cybersecurity maturity model for digitally transformed organizations is developed, along with its assessment methodology and automation tool. The model evaluation showed promising results in terms of the ability to identify the maturity level.

ABSTRACT Context Prioritizing usability in software development is vital to ensure a positive user experience and efficient performance. Failing to do so can result in negative consequences such as increased costs, damage to reputation, and loss of trust. Usability should be considered throughout the entire software development life cycle (SDLC), not just as an afterthought. Accordingly, adopting and integrating usability practices is crucial but can be complex. Thus, organizations must assess their readiness to start and improve usability initiatives. In this context, software organizations can benefit from using a usability readiness model to enhance integration and assist practitioners in systematically and structurally applying usability practices. Objective We propose a readiness model for usable software development (RMUSD). This model allows organizations to assess their readiness to create usable software, leading to improved user experience and better usability methods throughout the SDLC. Method To develop the RMUSD, we conducted a systematic mapping study that gathered 238 relevant studies in the usability engineering domain. From these studies, we synthesized 50 best usability practices that form the foundation of the RMUSD. We also drew inspiration from existing software engineering readiness and usability maturity models. Results The RMUSD is built at five levels, each with various aspects to consider, such as related usability practices, implications, organizational characteristics, and success factors for moving up to the next level. The model was evaluated through two real‐world case studies and eight experts. Conclusion The evaluation results reveal that the suggested RMUSD is practical in determining the organization's readiness to develop usable software.

ABSTRACT Context Automating code smell detection through a software bot offers significant benefits in terms of efficiency, code quality, and developer productivity. However, careful consideration of accuracy, integration, and user acceptance is also required to realize these benefits fully. While many previous studies have proposed deep learning models for this purpose, they often lack in automating their methodologies. Objective In this paper, we propose the design, development, and deployment of SmellyBot, an AI‐powered bot for code smell detection. Method We seamlessly integrated SmellyBot within the GitHub framework to detect four code smells, incorporating automated reporting to enhance code smell detection. Results Our evaluation involved 43 developers to assess user perception and feature recommendations, alongside an analysis of SmellyBot's performance on six real‐world projects to examine its efficiency and effectiveness. Conclusion The results indicate that developers perceive SmellyBot as highly useful and easy to use, and it has demonstrated notable efficiency and effectiveness in detecting code smells.

With the increase of code reuse, the possibility of security vulnerabilities increases. Thus, tools for static analysis are widely used to evaluate open-source projects against security vulnerabilities. This research aims to empirically study common weakness types (CWEs), their frequencies, and the correlations between them and open-source project characteristics. The PVS-Studio tool analyzed 150 projects hosted on GitHub and written in C#, C++, and Java. The tool was used to investigate the common weaknesses found in these projects. Furthermore, our study has practical implications for developers and researchers interested in open-source project security. We have identified the factors that contribute to the presence of these weaknesses, and our statistical analyses have shed light on these factors. Notably, C++ projects tend to have more weaknesses. The most common types of weaknesses detected in these programming languages are CWE-571, 570, 690, 682, 476, 628, 563, 691, 704, and 393. The age of the project and the number of commits are found to be positively correlated with the number of detected weaknesses, while stars and forks have little impact. These findings highlight the need for caution when using open-source code, as it can have several vulnerabilities that can compromise the software's security. Therefore, it is crucial to scan the third-party code before incorporating it into projects.

Code smells tend to have an impact on software quality attributes such as reusability, maintainability, and understandability. These are code flaws that do not necessarily prevent the system from operating; rather, they increase the possibility of defects occurring in the future. Hence, to maintain code quality, code smells should be detected and corrected through refactoring. The objective of this paper is to investigate the associated risk of applying refactoring techniques and reveal the bad smells that may appear when fixing other bad smells. We conducted several controlled experiments to identify the smells that emerge after refactoring. The experiments resulted in a novel taxonomy revealing 9 bad smells that may appear as a result of fixing other bad smells. This represents the first study attempting to systematically identify and organize such refactoring-smell relationships into a taxonomy. The research results can assist developers in relating different bad smells to each other and helping them determine the refactoring technique that should be applied when certain smells are present. Moreover, the results can be beneficial in breaking the cycle of bad smells. Such knowledge tends to enhance code refactoring, which in turn will improve software quality and avoid technical debt.

Abstract Software refactoring solutions aim at mitigating the negative effects of code and design smells on the overall software quality. Many efforts have been exerted to improve the software refactoring process. However, most of these efforts, despite their contributions, overlooked the side effects of the identified refactoring opportunities that may lead to new smells that will go unnoticed. This paper addresses the side effects of software refactoring and proposes sound solutions for handling them. Unlike current practices in software maintenance, we recommend three different approaches to handle the refactoring side effects. In the first approach, called the baseline, we opt to ignore the smells, caused by refactoring, while executing the identified refactoring decisions. In the second one, refactoring decisions are continually updated to fix all smells caused by side effects. In the last approach, only a subset of these smells is appended to the original smell sequence during the execution of the refactoring decisions. Thanks to the proposed approaches, optimal refactoring decisions are identified using a multi‐objective (MO) optimization algorithm commonly known as the MO covariance matrix adaptation evolution strategy (MO‐CMA‐ES). Experiment results corroborate our assumptions and show the superiority of the second approach over the other ones.

Abstract Security is an essential attribute of high‐quality software. However, effectively incorporating security practices into different phases of the software development life cycle (SDLC) remains challenging. Owing to less mature secure testing processes, organizations are prone to ineffective testing practices for defect detection, including severe security‐related failures. Thus, in this study, we present a maturity model for secure software testing (MMSST) to assist software development organizations in improving the secure testing of software applications. We conducted a multivocal literature review and identified 68 primary studies from the formal and gray literature. Then, based on the available evidence, 27 process areas were identified to develop the proposed MMSST. The MMSST includes five main categories: governance, contrive and design, execution, deployment and configuration, and mature. The MMSST was subsequently evaluated using case studies related to practical environments. Results demonstrate that the proposed MMSST is useful for estimating the maturity level of an organization with respect to the secure testing phase of the SDLC. The participants of the case studies also agreed that the proposed MMSST is useful in terms of structure, user satisfaction, and ease of use. We believe that the proposed MMSST can help organizations evaluate and improve software security testing practices. In addition, the proposed MMSST is expected to provide researchers and industry practitioners with an effective foundation for developing new secure testing approaches and tools.

Abstract Developers are encouraged to adopt good design practices to maintain good software quality during the system's evolution. However, some modifications and changes to the system could cause code smells and pattern grime, which might incur more maintenance effort. As the presence of both code smells and pattern grime is considered a bad sign and raises a flag at code segments that need more careful examination, a potential connection between them may exist. Therefore, the main objective of this paper is to (1) empirically investigate the potential relationship between the accumulation of pattern grime and the presence of code smells and (2) evaluate the significance of individual code smells when they appear in a specific pattern grime category. To achieve this goal, we performed an empirical study using six‐grime metrics and 10 code smells on five Java open‐source projects ranging from 217 to 563 classes. Our statistical results indicate that, in general, the growth of grime is more likely to co‐occur with code smells using Spearman's correlation and Odd Ratio test. Specifically, there is a strong positive association between the growth of pattern grime at the class level and the presence of Shotgun Surgery smell according to the result of applying the Apriori algorithm, which gives conviction values equal to 1.66. The findings in this paper are helpful for developers and researchers as the presence of pattern grime could be considered a factor in improving the performance of existing smell detection methods. Furthermore, the link between grime and smells can be exploited as a hint for smell distribution in the system.

Abstract Context Organizations constantly strive to protect their assets from outsider attacks by implementing various security controls, such as data encryption algorithms, intrusion detection software, firewalls, and antivirus programs. Unfortunately, attackers strike not only from outside the organization but also from within. Such internal attacks are called insider attacks or threats, and the people responsible for them are insider attackers or insider threat agents. Insider attacks pose more significant risks and can result in greater organizational losses than outsider attacks. Thus, every organization should be vigilant regarding such attackers to protect its valuable resources from harm. Finding solutions to protect organizations from such attacks is critical. Despite the importance of this topic, little research has been conducted on providing solutions to mitigate insider attacks. Objective This study aims to develop an organizational readiness model to assess an organization's readiness for insider attacks. Method We conducted a multivocal literature review to identify practices that can be used to assess organizations' readiness against insider attacks. These practices were grouped into different knowledge areas of insider attacks for organizations. The insider attack readiness model was developed using identified best practices and knowledge areas: compliance, top management, human resources, and technical. Results This model was evaluated at two levels—academic and real‐world environments. The evaluation results show that the proposed model can identify organizations' readiness against insider attacks. Conclusion The proposed model can guide organizations through a secure environment against insider attacks.

Abstract The heart of the application's secure operation is its software code. If the code contains flaws, the entire program might be hacked. The issue with software vulnerabilities is that they reveal coding flaws that hackers could exploit. The prevention of cybersecurity issues begins with the program code itself. When writing software code, a software developer must consider expressing the application's architecture and design requirements, keeping the code streamlined and efficient, and ensuring the code is safe. Secure code helps save the system from various cyber‐attacks by eliminating the weaknesses that many hacks rely on. To assist the software organization in Secure Software Coding (SSC), this article proposes a readiness model for SSC, namely SSCRM. The proposed model has five levels; SSC challenges and best practices (BP) are mapped at each level. The proposed model will help the organizations better understand SSC challenges and BPs and provide a roadmap for developing secure software code. The proposed model was evaluated using three case studies. The findings demonstrate that the proposed approach helps determine an organization's SSC level.

Abstract Software smells indicate design or code issues that might degrade the evolution and maintenance of software systems. Detecting and identifying these issues are challenging tasks. This paper explores, identifies, and analyzes the existing software smell detection techniques at design and code levels. We carried out a systematic literature review (SLR) to identify and collect 145 primary studies related to smell detection in software design and code. Based on these studies, we address several questions related to the analysis of the existing smell detection techniques in terms of abstraction level (design or code), targeted smells, used metrics, implementation, and validation. Our analysis identified several detection techniques categories. We observed that 57% of the studies did not use any performance measures, 41% of them omitted details on the targeted programing language, and the detection techniques were not validated in 14% of these studies. With respect to the abstraction level, only 18% of the studies addressed bad smell detection at the design level. This low coverage urges for more focus on bad smell detection at the design level to handle them at early stages. Finally, our SLR brings to the attention of the research community several opportunities for future research.

There is a significant need to give careful consideration to the Capability Maturity Model Integration (CMMI) level 2 specific practices (i.e. SP 1.1 ‘understand requirements’ and SP 1.2 ‘obtain commitment to requirements’), especially in the context of small‐ and medium‐sized software development organisations, in order to assist such organisations in effectively managing their requirements engineering processes. In this study, the authors propose an abstract‐level model for each of these two specific practices as well as cover the initial evaluation of the models. In addition, necessary templates and checklists are also provided for each proposed model. The proposed models are based on a significant amount of research in software process improvement, CMMI and requirements engineering. The initial evaluation of the proposed models was executed using an expert panel review process. The results showed that the proposed models provide ease of learning and ease of use, provide stakeholder satisfaction and can be applied to small‐and medium‐sized software development organisations. It is important to highlight that this study contributes not only to the implementation of SP 1.1 and SP 1.2 of REQM process area in the context of small‐ and medium‐sized software development organisations but also to the body of knowledge on REQM.

Abstract In global software development (GSD), software is developed by a team of geographically dispersed people. Many organizations that develop projects globally do not evaluate their project management readiness to undertake such projects. The objective of this paper is to propose a global project management readiness framework (GLOB) to help organizations in evaluating and assessing their GSD project management readiness to improve their capabilities in managing GSD projects. To develop GLOB, three systematic literature reviews (SLRs) were conducted. For each SLR, an empirical study was conducted with GSD practitioners to validate the SLR results in a real‐world environment. We identified 45 factors that can play a positive or negative role in global project management readiness. In total, 305 best practices were identified for global project management. Based on the findings of the SLRs and empirical studies, GLOB was developed. Two case studies were conducted to evaluate GLOB in a real‐world context. The case study results show that GLOB has the potential to measure an organization's project management readiness for global projects. It is hoped that GLOB will provide GSD practitioners with the ability to understand the strengths and weaknesses of current project management processes and to address weak areas.

Abstract The need to ensure the quality of software is growing in importance on a daily basis due to the growing role of software in critical products and application areas, such as defense, aerospace, aviation, and medicine. To meet this need, many organizations use the Capability Maturity Model Integration process model to assess and improve software development processes. This paper proposes a framework for measuring software product maturity as an indicator of product quality. The proposed framework consists of two parts: a reference model and an assessment method. The reference model provides a platform for gathering product quality indicators as evidence of product capability, which reflects the product's maturity. The quality indicators are then used to assess the product maturity level. The assessment method utilizes standard steps for assessing product maturity that are reflected in the degree of the product's conformance with the relevant quality attributes defined and agreed upon by the product's stakeholders. The proposed framework enables measuring the quality of the product from the developers' and the users' perspective. The proposed maturity model and the assessment method can help software organizations and software clients ensure that software products meet the appropriate quality levels.

Abstract Bad smells tend to have a negative impact on software by degrading its quality. It is beneficial to detect model smells to avoid their propagation to later stages of software development. The objective of this paper is to present the state‐of‐the‐art research on techniques for detecting UML model bad smells. The detection techniques are compared and evaluated using a proposed evaluation framework. The framework consists of two parts. The first part of the framework compares the techniques in terms of the implemented approach, the investigated model, and the explored model smells, while the experimental design is explored in the second part of the framework. We found that the detection of bad smells in class and sequence diagrams is accomplished via design patterns, software metrics, and predefined rules, while model smells in use cases are detected using metrics and predefined rules. We also found that the class diagram is the most investigated UML model in the context of model smell detection, whereas there is a lack of work on other UML models. In addition, there is a scarcity of independent studies on sequence diagrams. Furthermore, the studies investigating class diagrams are mostly validated, whereas use case diagrams and sequence diagrams are rarely validated.

Managing communication in collaborative global software development (GSD) projects is both critical and challenging. While social computing has received much attention from practitioners, social computing adoption is still an emerging research area in GSD. This research paper provides a review of the academic research in social computing and identifies motivators for adopting social computing in the GSD context. We applied the systematic literature review (SLR) and questionnaire survey with 35 software industry experts to address the research objective. Firstly, we implemented a formal SLR approach and identified an initial set of social computing adoption motivators. Secondly, a questionnaire survey was developed based on the SLR and was tested by means of a pilot study. The findings of this combined SLR and questionnaire survey indicate that real-time communication and coordination, knowledge acquisition, expert feedback, and information sharing are the key factors that motivate social computing adoption in GSD projects. The results of t test (ie, t = .558, P = .589) show that there is no significant difference between the findings of SLR and questionnaire. The results of this study suggest the need for developing social computing strategies and policies to guide the strategic adoption of social computing tools in GSD projects.

The unified modeling language (UML) is one of the most commonly used modeling languages in the software industry. It simplifies the complex process of design by providing a set of graphical notations, which helps express the objectoriented analysis and design of software projects. Although UML is applicable to different types of systems, domains, methods, and processes, it cannot express certain problem domain needs. Therefore, many extensions to UML have been proposed. In this paper, we propose a framework for integrating the UML extensions and then use the framework to propose an integrated unified modeling language-graphical (iUML-g) form. iUML-g integrates the existing UML extensions into one integrated form. This includes an integrated diagram for UML class, sequence, and use case diagrams. The proposed approach is evaluated using a case study. The proposed iUML-g is capable of modeling systems that use different domains.

Over the last decade, an increasing number of organizations have started software development in a globally distributed environment. One of the major challenges is that many organizations endorse the process of global software development without testing their management readiness for the globally distributed development activity. This includes work distribution through task allocation in the globally distributed development environment. The objective of this research paper is to identify factors that influence task allocation in global software development through carrying out a systematic literature review. We used customized search terms, derived from our research question, to identify literature on work distribution and task allocation in a global context. We identified criteria such as site technical expertise, time zone difference, resource cost, task dependency, vendor reliability, task size and vendor maturity level as key task allocation factors in globally distributed software projects. Based on the systematic literature review results, we suggest that there is a need to develop work distribution strategies and standards through global task allocation to help software development organizations in achieving the true potential of global software development at lower development costs and shorter time-to-market.

Software design patterns are solutions to recurring problems. These solutions have been widely accepted and adopted by the software practitioners. Design Patterns were initially described informally through the use of textual descriptions or some object oriented graphical notations. However, informal descriptions of design patterns give rise to ambiguity and incorrect usage of the design pattern. Many design pattern specification languages have been proposed to address the shortcomings of informal descriptions. These design pattern formalization techniques have been developed for different intentions including verification of design patterns and detection of design patterns in source code. In this paper we provide a set of evaluation criteria to evaluate and compare the various design pattern specification languages in order to aid practitioners and researchers to select the appropriate language for their use.

Systematic software reuse facilitates achieving quality software, faster and at a lower cost. Software reuse environments play an important role in exploiting reusable artifacts to the extent. Environments that support reusing early-stage software artifacts are of great interest. There have been a number of reuse environments proposed in the literature for reuse of software artifacts. However, there is no framework to allow analyzing (i.e. classifying and comparing) reuse environments. The significance of such a framework is twofold: (1) to be used by reuse practitioners to select appropriate environment; and (2) to be used by researchers to identify gaps for future research. In this paper, we present an attribute-based framework to provide such aid to practitioners and researchers. The paper also presents an indicative survey of current reuse environments proposed for systematic reuse of software artifacts. We use the framework to analyze those reuse environments. The analysis provides an understanding of current systematic reuse approaches and respective reuse environments; and identifies corresponding shortcomings. Consequently, we post research questions for future work.

SUMMARY Refactoring improves software quality by improving the design of existing code through changing its internal structure while preserving its behavior. Improving one quality attribute may impair other quality attributes. A number of refactoring methods were proposed specifically for aspect‐oriented systems. However, there are no guidelines to help aspect‐oriented software designer decide which refactoring methods to apply to optimize a software system with regard to certain design goals. In this paper, we propose a taxonomy/classification of refactoring methods for aspect‐oriented programming based on their measurable effect on software quality attributes using six open‐source aspect‐oriented software systems. Copyright © 2011 John Wiley & Sons, Ltd.

SUMMARY Design patterns are rapidly gaining acceptance in the software community not only as reusable constructs for software development but also for the documentation of the software architectural design. Most of the existing design pattern languages describe design patterns using a combination of a natural language, UML‐style diagrams and complex mathematical or logic based formalisms, which makes them hard for programmers to understand. In this paper we propose a design pattern definition language (DPDL) based on XML which can be used for sharing design patterns’ implementation details among developers. DPDL is easy to understand and use. It provides unambiguous description of the patterns and is extensible. DPDL also has the flexibility of defining design patterns in a generic term to be used as templates. Copyright © 2011 John Wiley & Sons, Ltd.

In this paper, we report our comprehensive Arabic offline Handwritten Text database (KHATT) after completion of the collection of 1000 handwritten forms written by 1000 writers from different countries. It is composed of an image database containing images of the written text at 200, 300, and 600 dpi resolutions, a manually verified ground truth database that contains meta-data describing the written text at the page, paragraph, and line levels. A formal verification procedure is implemented to align the handwritten text with its ground truth at the form, paragraph and line levels. Tools to extract paragraphs from pages and segment paragraphs into lines are developed. Preliminary experiments on Arabic handwritten text recognition are conducted using sample data from the database and the results are reported. The database will be made freely available to researchers world-wide for research in various handwritten-related problems such as text recognition, writer identification and verification, etc.

Specification of object-oriented systems by UML models has become an eminent practice among software practitioners. UML Sequence diagrams are used to model the dynamic behavior of the software system depicting how objects interact by passing messages. The UML Metamodel, which is contained in the UML Specification Version 2, has undergone a significant change with respect to sequence diagrams. Complex logic that allows message exchange between objects in a non-sequential manner was made possible through the use of combined fragments. The UML metamodel is used by design tools to verify the correctness of the constructed models. Ensuring well-formedness of these models still remains a challenging task mainly due to unavailability of a formal description for some rules listed in the UML specification. In this paper, we propose an extension to the UML metamodel that eliminates some well-formedness rules defined over combined fragments in UML sequence diagrams. This is achieved by introducing new metaclasses in the UML metamodel. The proposed solution also provides ease for future metamodel extensions and a better mapping framework between the UML metamodel and program code assisting in enhanced reverse engineering.

Refactoring, the process of improving the design of existing code by changing its internal structure without affecting its external behavior, tends to improve software quality by improving design, improving readability, and reducing bugs. There are many different refactoring methods, each having a particular purpose and effect. Consequently, the effect of refactorings on software quality attribute may vary. Software testing is an external software quality attributes that takes lots of time and effort to make sure that the software performs as intended. In this paper, we propose a classification of refactoring methods based on their measurable effect on software testing effort. This, in turn, helps the software developers decide which refactoring methods to apply in order to optimize a software system with regard to the testing effort.

Object-oriented (OO) metrics are used mainly to predict software engineering activities/efforts such as maintenance effort, error proneness, and error rate. There have been discussions about the effectiveness of metrics in different contexts. In this paper, we present an empirical study of OO metrics in two iterative processes: the short-cycled agile process and the long-cycled framework evolution process. We find that OO metrics are effective in predicting design efforts and source lines of code added, changed, and deleted in the short-cycled agile process and ineffective in predicting the same aspects in the long-cycled framework process. This leads us to believe that OO metrics' predictive capability is limited to the design and implementation changes during the development iterations, not the long-term evolution of an established system in different releases.