Search

Abstract The software engineering community aims to achieve and maintain high‐efficient software engineering practical activities. One of the techniques used for this purpose is Test‐Driven Development (TDD), which is a cyclic and test‐centered development method positively related to maintainability, which may vary depending on the context and application. Previous research has indicated that TDD's benefits on maintainability may be due to the improved focus on coding and testing activities. However, limited research has investigated the role of engagement in software quality. Therefore, this study investigates the relationship between TDD methods, engagement level in development activities, and maintainability. The primary research questions addressed in this study are does following TDD methods improve the engagement level in development activities? And does a higher engagement level leads to better maintainability? The study employs a statistical analysis technique, regression analysis to explore the research questions. The results show that TDD behaviours improve the engagement level, and engaging in development activities has a significant positive impact on maintainability. Additionally, the study finds that the positive impact of focussing on testing, such as writing more test cases, is more pronounced compared to coding activities. Our study adds to current software engineering literature that not only personal expertise but the engagement level in the development process are associated with software quality and calls for the emphasis on developer's engagement.

Abstract As more and more software teams use online issue tracking systems to collaborate on software projects, the accurate assignment of new issues to the most suitable contributors may have significant impact on the success of the project. As a result, several research efforts have been directed towards automating this process to save considerable time and effort. However, most approaches focus mainly on software bugs and employ models that do not sufficiently take into account the semantics and the non‐textual metadata of issues and/or produce models that may require manual tuning. A methodology that extracts both textual and non‐textual features from different types of issues is designed, providing a Jira dataset that involves not only bugs but also new features, issues related to documentation, patches, etc. Moreover, the semantics of issue text are effectively captured by employing a topic modelling technique that is optimised using the assignment result. Finally, this methodology aggregates probabilities from a set of individual models to provide the final assignment. Upon evaluating this approach in an automated issue assignment setting using a dataset of Jira issues, the authors conclude that it can be effective for automated issue assignment.

The software engineering community aims to achieve and maintain high‐efficient software engineering practical activities. One of the techniques used for this purpose is Test‐Driven Development (TDD), which is a cyclic and test‐centered development method positively related to maintainability, which may vary depending on the context and application. Previous research has indicated that TDD's benefits on maintainability may be due to the improved focus on coding and testing activities. However, limited research has investigated the role of engagement in software quality. Therefore, this study investigates the relationship between TDD methods, engagement level in development activities, and maintainability. The primary research questions addressed in this study are does following TDD methods improve the engagement level in development activities? And does a higher engagement level leads to better maintainability? The study employs a statistical analysis technique, regression analysis to explore the research questions. The results show that TDD behaviours improve the engagement level, and engaging in development activities has a significant positive impact on maintainability. Additionally, the study finds that the positive impact of focussing on testing, such as writing more test cases, is more pronounced compared to coding activities. Our study adds to current software engineering literature that not only personal expertise but the engagement level in the development process are associated with software quality and calls for the emphasis on developer's engagement. [ABSTRACT FROM AUTHOR]

Students engage in remote learning within a diverse computer environment. While virtual machines can address the challenges posed by heterogeneity, there remain unresolved issues, particularly related to the complexity of software management. An imperative is to discover an automated solution that facilitates the creation of consistent software environments for educational purposes. This paper introduces ontology engineering principles as a means to tackle the complexities associated with software management. A suitable ontology is developed using OWL syntax, integrating knowledge pertaining to the required software within a specific academic domain. The practical applicability of this knowledge is enabled through the implementation of dedicated SPARQL queries within a Python program. The effectiveness of the automated solution in achieving identical software environments is verified through testing, conducted in both controlled laboratory settings and by students themselves, thus simulating authentic teaching scenarios. The solution not only adheres to the principles of reusability but can also be adapted or integrated into existing ontologies. Furthermore, it presents an opportunity to create automated and self-adjusting virtual machines, offering significant potential for educational and other domains. [ABSTRACT FROM AUTHOR]

As more and more software teams use online issue tracking systems to collaborate on software projects, the accurate assignment of new issues to the most suitable contributors may have significant impact on the success of the project. As a result, several research efforts have been directed towards automating this process to save considerable time and effort. However, most approaches focus mainly on software bugs and employ models that do not sufficiently take into account the semantics and the non‐textual metadata of issues and/or produce models that may require manual tuning. A methodology that extracts both textual and non‐textual features from different types of issues is designed, providing a Jira dataset that involves not only bugs but also new features, issues related to documentation, patches, etc. Moreover, the semantics of issue text are effectively captured by employing a topic modelling technique that is optimised using the assignment result. Finally, this methodology aggregates probabilities from a set of individual models to provide the final assignment. Upon evaluating this approach in an automated issue assignment setting using a dataset of Jira issues, the authors conclude that it can be effective for automated issue assignment. [ABSTRACT FROM AUTHOR]

For small public water systems, vulnerability to cyberattacks is a serious concern. This is especially true for systems operating on a low budget for upgrading outdated information technology equipment and cybersecurity plans. [ABSTRACT FROM AUTHOR]

The article sets forth and analyzes the milestones of management of software as intellectual property. Software is assessed as an asset of the company's intellectual property (IP) portfolio. Protection options for a software program are specified, and each option is considered in terms of the company's market strategy and further commercialization. Commercialization stage is placed under close scrutiny with relevant examples and reasoning. The role of a trademark in commercialization process is evaluated. [ABSTRACT FROM AUTHOR]

Copyright of Smart Rail Transit is the property of Smart Rail Transit Editorial Office and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Copyright of Journal of Business & Projects / Revista de Gestão e Projetos is the property of Revista de Gestao e Projetos and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

Around the world, the importance of Very Small Entities (VSEs), organisations having up to 25 people, has been constantly increasing. Worldwide, VSEs represent over 92% of the software industry. Therefore, two main needs can be highlighted: a) providing VSEs with resources to produce high‐quality software, and b) training software engineering undergraduates in proven practices to produce high‐quality software within the given schedule and budget. A logical way to meet these needs is transfering proven practices provided by software engineering standards. However, transferring the knowledge of software engineering standards is not always an easy task. The ISO/IEC 29110 is a series of international standards and guides that provide codified knowledge related to the software development process. The series was specifically developed to be used by VSEs. This study presents an exploratory analysis, conducted in 12 Mexican VSEs, which implemented the software Basic profile of the ISO/IEC 29110, to identify the pace at which they can adopt this standard to their environment. Besides, the benefits and difficulties encountered are provided. The results can be relevant for other VSEs interested in implementing this standard. Even if the exploratory analysis was performed in the VSEs of Mexico, this analysis can be of interest in other countries. The results obtained can help other VSEs that are interested in the adoption of this international standard to reduce the barriers to a successful implementation. [ABSTRACT FROM AUTHOR]

Great strides have been made to encourage researchers to archive data created by research and provide the necessary systems to support their storage. Additionally it is recognised that data are meaningless unless their provenance is preserved, through appropriate meta-data. Alongside this is a pressing need to ensure the quality and archiving of the software that generates data, through simulation, control of experiment or data-collection and that which analyses, modifies and draws value from raw data. In order to meet the aims of reproducibility we argue that data management alone is insufficient: it must be accompanied by good software practices, the training to facilitate it and the support of stakeholders, including appropriate recognition for software as a research output.

Feedback from software users, such as bug reports, is vital in the management of software projects. In GitHub, the feedback is typically expressed as new issues. Through filing issue reports, users may help identify and fix bugs, document software code, and enhance software quality via feature requests. In this paper, we aim at investigating some characteristics of issues to facilitate issue management and software management. We investigate the important degrees of behaviors that are related to issues in popular projects to assess the importance of issues in GitHub and analyze the effectiveness of issue labeling for issue handling. Then, we explore the patterns of issue commits over time in popular projects based on visual analysis and obtain the following results: we find that the behaviors that are related to issues play important roles in the GitHub. We also find that the time distribution of issue commits follows a three-period development model, which approximately corresponds to the project life cycle. These results may provide a new knowledge about issues that can help managers manage and allocate project resources more effectively and even reduce software failures.

The processes involved in requirements engineering are some of the most, if not the most, important steps in systems development. The need for well-defined requirements remains a critical issue for the development of any system. Describing the structure and behavior of a system could be proven vague, leading to uncertainties, restrictions, or improper functioning of the system that would be hard to fix later. In this context, this article proposes SENSE, a framework based on standardized expressions of natural language with well-defined semantics, called boilerplates, that support a flow-down procedure for requirement management. This framework integrates sets of boilerplates and proposes the most appropriate of them, depending, among other considerations, on the type of requirement and the developing system, while providing validity and completeness verification checks using the minimum consistent set of formalities and languages. SENSE is a consistent and easily understood framework that allows engineers to use formal languages and semantics rather than the traditional natural languages and machine learning techniques, optimizing the requirement development. The main aim of SENSE is to provide a complete process of the production and standardization of the requirements by using semantics, ontologies, and appropriate NLP techniques. Furthermore, SENSE performs the necessary verifications by using SPARQL (SPIN) queries to support requirement management.

Copyright of Dokuz Eylul University Muhendislik Faculty of Engineering Journal of Science & Engineering / Dokuz Eylül Üniversitesi Mühendislik Fakültesi Fen ve Mühendislik Dergisi is the property of Dokuz Eylul Universitesi Muhendislik Fakultesi Fen ve Muhendislik Dergisi and its content may not be copied or emailed to multiple sites or posted to a listserv without the copyright holder's express written permission. However, users may print, download, or email articles for individual use. This abstract may be abridged. No warranty is given about the accuracy of the copy. Users should refer to the original published version of the material for the full abstract. (Copyright applies to all Abstracts.)

This paper presents a methodology for Mining Association Rules from Code (MARC), aiming at capturing program structure, facilitating system understanding and supporting software management. MARC groups program entities (paragraphs or statements) based on similarities, such as variable use, data types and procedure calls. It comprises three stages: code parsing/analysis, association rule mining and rule grouping. Code is parsed to populate a database with records and respective attributes. Association rules are then extracted from this database and subsequently processed to abstract programs into groups containing interrelated entities. Entities are then grouped together if their attributes participate to common rules. This abstraction is performed at the program level or even the paragraph level, in contrast to other approaches that work at the system level. Groups can then be visualised as collections of interrelated entities. The methodology was evaluated using real-life COBOL programs. Results showed that the methodology facilitates program comprehension by using source code only, where domain knowledge and documentation are either unavailable or unreliable. [ABSTRACT FROM AUTHOR]

Every year software development industry requires a higher number of trained software engineers who are not only skilled programmers but also talented software projects managers. To deliver high‐quality software projects, engineers require of the application of sound engineering competencies along with discipline. Obtaining those practices usually require years of experience. Companies are not prepared to invest this time on engineers resulting in a high percentage of deficient projects. Here, the authors present a bachelor‐level competency‐based approach that develops and evaluates such competencies during a challenge‐based learning experience. In this way, the rate of successful projects where software engineers are involved will be higher, as they have obtained the appropriate competencies to deliver such projects. [ABSTRACT FROM AUTHOR]

Transcriptomic reconstructions without reference (i.e., de novo) are common for data samples derived from non-model biological systems. These assemblies involve massive parallel short read sequence reconstructions from experiments, but they usually employ ad-hoc bioinformatic workflows that exhibit limited standardization and customization. The increasing number of transcriptome assembly software continues to provide little room for standardization which is exacerbated by the lack of studies on modularity that compare the effects of assembler synergy. We developed a customizable management workflow for de novo transcriptomics that includes modular units for short read cleaning, assembly, validation, annotation, and expression analysis by connecting twenty-five individual bioinformatic tools. With our software tool, we were able to compare the assessment scores based on 129 distinct single-, bi- and tri-assembler combinations with diverse k-mer size selections. Our results demonstrate a drastic increase in the quality of transcriptome assemblies with bi- and tri- assembler combinations. We aim for our software to improve de novo transcriptome reconstructions for the ever-growing landscape of RNA-seq data derived from non-model systems. We offer guidance to ensure the most complete transcriptomic reconstructions via the inclusion of modular multi-assembly software controlled from a single master console.

Bug report processing is a key element of bug fixing in modern software maintenance. Bug reports are not processed immediately after submission and involve several processes such as bug report deduplication and bug report triage before bug fixing is initiated; however, this method of bug fixing is very inefficient because all these processes are performed manually. Software engineers have persistently highlighted the need to automate these processes, and as a result, many automation techniques have been proposed for bug report processing; however, the accuracy of the existing methods is not satisfactory. Therefore, this study focuses on surveying to improve the accuracy of existing techniques for bug report processing. Reviews of each method proposed in this study consist of a description, used techniques, experiments, and comparison results. The results of this study indicate that research in the field of bug deduplication still lacks and therefore requires numerous studies that integrate clustering and natural language processing. This study further indicates that although all studies in the field of triage are based on machine learning, results of studies on deep learning are still insufficient. [ABSTRACT FROM AUTHOR]

Code clones are created when a developer duplicates a code fragment to reuse existing functionalities. Mitigating clones by refactoring them helps ease the long-term maintenance of large software systems. However, refactoring can introduce an additional cost. Prior work also suggest that refactoring all clones can be counterproductive since clones may live in a system for a short duration. Hence, it is beneficial to determine in advance whether a newly-introduced clone will be short-lived or long-lived to plan the most effective use of resources. In this work, we perform an empirical study on six open source Java systems to better understand the life expectancy of clones. We find that a large number of clones (i.e., 30% to 87%) lived in the systems for a short duration. Moreover, we find that although short-lived clones were changed more frequently than long-lived clones throughout their lifetime, short-lived clones were consistently changed with their siblings less often than long-lived clones. Furthermore, we build random forest classifiers in order to determine the life expectancy of a newly-introduced clone (i.e., whether a clone will be short-lived or long-lived). Our empirical results show that our random forest classifiers can determine the life expectancy of a newly-introduced clone with an average AUC of 0.63 to 0.92. We also find that the churn made to the methods containing a newly-introduced clone, the complexity and size of the methods containing the newly-introduced clone are highly influential in determining whether the newly-introduced clone will be short-lived. Furthermore, the size of a newly-introduced clone shares a positive relationship with the likelihood that the newly-introduced clone will be short-lived. Our results suggest that, to improve the efficiency of clone management efforts, practitioners can leverage our classifiers and insights in order to determine whether a newly-introduced clone will be short-lived or long-lived to plan the most effective use of their clone management resources in advance. [ABSTRACT FROM AUTHOR]

The popularity of mobile devices has accelerated the development of many industries, and Android mobile software is emerging. So Android software development plays an important role in development of mobile phone software.Differing from the traditional APP development mode, this paper designs an Android experiment system based on modularized, and uses it as the core experiment content of the 4 G test network which was equipped in the laboratory to train students’ mobile phone software developing ability. The core of the design is to construct an UI environment to realize the blockade of mobile phone communication, and then an addition is achieved by increasing the single function of APP in all of the software modules. This model can improve the legal management of special mobile phone software, and make program easier. Finally, we design an emergency command and dispatch software to test this system. The test result shows that the system is effective and achieves the design goal. [ABSTRACT FROM AUTHOR]

Software management systems need to preserve integrity by the handling, approval, tracking and execution of changes on the packages of the current installation profile. This is a problematic task, which needs to be accounted for both in terms of installation of new packages and removal of conflicting ones. While existing approaches are able to identify dependency satisfaction and conflicts, a broader and efficient approach can be formalised in terms of trust. Positive instances of trust are required by the identification of safely installable packages. Negative trust, a much less explored concept, can be useful to analyse the complementary issue of packages' removal both in case of conflicts and of security issues. In this paper we develop a logic of negative trust with two aims: identifying packages that are undesirable in view of the current installation profile; and currently installed packages that become inconsistent with a new intended installation. The logic provides distinct procedures for the identification of either case. We illustrate properties of the calculus, provide a simple working example and offer a translation of the protocol to the Coq proof assistant for verification of its formal correctness. [ABSTRACT FROM AUTHOR]