Search

Summary: In software development, developer turnover is among the primary reasons for project failures, leading to a great void of knowledge and strain for newcomers. Unfortunately, no established methods exist to measure how the problem domain knowledge is distributed among developers. Awareness of how this knowledge evolves and is owned by key developers in a project helps stakeholders reduce risks caused by turnover. To this end, this paper introduces a novel, realistic representation of problem domain knowledge distribution: the ConceptRealm. To construct the ConceptRealm, we employ a latent Dirichlet allocation model to represent textual features obtained from 300 K issues and 1.3 M comments from 518 open‐source projects. We analyze whether the newly emerged issues and developers share similar concepts or how aligned the individual developers' concepts are with the team over time. We also investigate the impact of leaving developers on the frequency of concepts. Finally, we also evaluate the soundness of our approach on a closed‐source software project, thus allowing the validation of the results from a practical standpoint. We find out that the ConceptRealm can represent the problem domain knowledge within a project and can be utilized to predict the alignment of developers with issues. We also observe that projects exhibit many keepers independent of project maturity and that abruptly leaving keepers correlates with a decline of their core concepts as the remaining developers cannot quickly familiarize themselves with those concepts. [ABSTRACT FROM AUTHOR]

Automated software transformations and the process of automated program repair and improvement are an important aspect of modern software engineering practices. In this paper, we describe a system which uses a graph-based deep learning model that can be trained to automatically transform and improve computer programs. By operating on language-agnostic, universal graph-like structures easily extractable from source code files (abstract syntax trees), the deep learning agent learns which transformations should be effectively applied to various structures recognized in the source code in order to improve it. By defining a metric which we want to improve and introducing an optimization task—a reinforcement learning setting, an agent learns to automatically apply a chain of transformations to the program, drastically improving it. While similar program improvement processes exist, they exclusively use exhaustive search algorithms to try all the possible code transformations which is a long process susceptible to local optimum issues. Our solution aims to model and embed structural knowledge about the programs being transformed which greatly helps the agent to choose best possible code transformations to apply. Elements of the approach we present in this paper are further applicable not just to automatic software improvement tasks, but also to other code-related tasks. [ABSTRACT FROM AUTHOR]

Models are the key tools humans use to manage complexity in description, development, and analysis. This applies to all scientific and engineering disciplines and in particular to the development of software and data-intensive systems. However, different methods and terminologies have become established in the individual disciplines, even in the sub-fields of Informatics, which raises the need for a comprehensive and cross-sectional analysis of the past, present, and future of modeling research. This paper aims to shed some light on how different modeling disciplines emerged and what characterizes them with a discussion of the potential toward a common modeling future. It focuses on the areas of software, data, and process modeling and reports on an analysis of the research approaches, goals, and visions pursued in each, as well as the methods used. This analysis is based on the results of a survey conducted in the communities concerned, on a bibliometric study, and on interviews with a prominent representative of each of these communities. The paper discusses the different viewpoints of the communities, their commonalities and differences, and identifies possible starting points for further collaboration. It further discusses current challenges for the communities in general and modeling as a research topic in particular and highlights visions for the future. [ABSTRACT FROM AUTHOR]

Software effort estimation is a vital process in the software industry for successfully administering 5Ds of the software development life cycle (SDLC). The 5Ds stand for demand, development, direction, deployment, and designated cost of the software. Software development effort estimation (SDEE) is an effort prediction mechanism to calculate the effort for the development of the software product in order to minimize the challenges in the software field. Academics and practitioners are striving to identify which machine learning estimation technique yields more accurate results based on evaluation metrics, datasets, and other pertinent aspects. The feature selection techniques impact accuracy by selecting the main and relevant features in the dataset and eliminating the redundant and irrelevant features in the dataset. To achieve accurate estimations, the paper utilizes feature selection algorithms, along with various machine learning techniques, which predict the desired effort and the performance of the model has been measured in terms of prediction accuracy, R2 value, relative error, and mean absolute error. The datasets China and Maxwell are trained with the relevant features by applying feature selection algorithms, and estimation techniques are applied to predict the effort. The performance is compared with the regression models and feature selection techniques utilized by many authors previously. The result of the proposed methodology significantly gives the best performance with the combination of feature selection and estimation models than all regression models when applied alone, to both datasets. From the results, it is perceptible that random forest is performing well with the feature selection techniques and obtains the highest prediction accuracy of 99.33% with the China and 89.47% with the Maxwell datasets. [ABSTRACT FROM AUTHOR]

The nine papers in this special section focus on new developments in agile software and reports on applications for its use. A key aspect for the extensive use of agile software is that it supports developers with coping with the growing uncertainty and turbulence in technological and market environments. Feedback and change are at the core of Agile for a dynamic, evolving, and organic, rather than static, predefined, and mechanistic development process advocated by waterfall management. To create timely, high-quality, cost-efficient, and innovative solutions, Agile developers organized in small, colocated, autonomous teams, build and test software in rapid iterative cycles, actively involving users to gather feedback, updating the project scope, and plan "on-the-fly," using face-to-face communication as opposed to documentation. These papers contribute to the state-of-the-art of agile research by offering a rich, up-todate account of the dynamics occurring when expanding Agile into "not-just-software" contexts of the key challenges and perils related to the scaling and of the possible solutions to them. [ABSTRACT FROM AUTHOR]

Concept drift (CD) refers to a phenomenon where the data distribution within datasets changes over time, and this can have adverse effects on the performance of prediction models in software engineering (SE), including those used for tasks like cost estimation and defect prediction. Detecting CD in SE datasets is difficult, but important, because it identifies the need for retraining prediction models and in turn improves their performance. If the concept drift is caused by symmetric changes in the data distribution, the model adaptation process might need to account for this symmetry to maintain accurate predictions. This paper explores the impact of CD within the context of cross-version defect prediction (CVDP), aiming to enhance the reliability of prediction performance and to make the data more symmetric. A concept drift detection (CDD) approach is further proposed to identify data distributions that change over software versions. The proposed CDD framework consists of three stages: (i) data pre-processing for CD detection; (ii) notification of CD by triggering one of the three flags (i.e., CD, warning, and control); and (iii) providing guidance on when to update an existing model. Several experiments on 30 versions of seven software projects reveal the value of the proposed CDD. Some of the key findings of the proposed work include: (i) An exponential increase in the error-rate across different software versions is associated with CD. (ii) A moving-window approach to train defect prediction models on chronologically ordered defect data results in better CD detection than using all historical data with a large effect size (δ ≥ 0.427) . [ABSTRACT FROM AUTHOR]

Requirements prioritization is essential for development of quality software products. Requirements prioritization helps focus on the most important requirements between the available software requirements. This process is also called preserving core vision according to customer viewpoint or managing the quality requirements. Many requirements prioritization techniques have been proposed in the Software Engineering field. However, one requirement prioritization technique can only be generalized for some software projects. This research effort aims to develop a sustainable hybrid model for requirements prioritization, utilizing critical software project factors. The prioritization technique is shortlisted from a pool of software prioritization techniques, based on these project factors and their quantized scores. The proposed model is equipped with state-of-the-art literature to provide a customized prioritization technique improving the requirements prioritization process for a specific software project. The paper also presents popular software prioritization techniques used in the software industry and an extensive comparison using a thorough empirical analysis. Finally, the quantization of the software project factors for each technique has been assessed for better understanding, and a sustainable hybrid model has been constructed. With the proposed hybrid model, requirements prioritization in software development has been controlled effectively, reducing the failure risks and increasing the overall benefit and success rate. The success of the proposed hybrid approach is verified with two software case studies attaining satisfactory results and improving the organization's productivity by incorporating pivotal software requirements on which all the stakeholders agree. Furthermore, an automated approach will be developed by implementing the proposed approach to benefit from human–machine collaboration, improving user satisfaction by incorporating end-user opinions effectively and timely. [ABSTRACT FROM AUTHOR]

Engineers use software defect prediction (SDP) to locate vulnerable areas of software. Recently, statement-level SDP has attracted the attention of researchers due to its ability to localize faulty code areas. This paper proposes DP-Tramo, a new model dedicated to improving the state-of-the-art statement-level SDP. We use Clang to extract abstract syntax trees from source code and extract 32 statement-level metrics as static features for each sentence. Then we feed static features and token sequences as inputs to our improved R-Transformer to learn the syntactic and semantic features of the code. Furthermore, we use label smoothing and weighted loss to improve the performance of DP-Tramo. To evaluate DP-Tramo, we perform a 10-fold cross-validation on 119,989 C/C++ programs selected from Code4Bench. Experimental results show that DP-Tramo can classify the dataset with an average performance of 0.949, 0.602, 0.734 and 0.737 regarding the recall, precision, accuracy and F1-measure, respectively. DP-Tramo outperforms the baseline method on F1-measure by 1.2% while maintaining a high recall rate. [ABSTRACT FROM AUTHOR]

Software bug prediction aims to enhance software quality and testing efficiency by constructing predictive classification models using code properties. This enables the prompt detection of fault‐prone modules. There are several machine learning‐based software bug prediction studies, which mainly focus on single view data by disregarding the natural ordering relation among the class labels in the literature. Thus, these studies cause losing each view's own intrinsic structure and the inherent order of the labels that positively affect the prediction performance. To overcome this drawback, this study focuses on integrating ordering information and a multi‐view learning strategy. This paper proposes a novel approach multi‐view ordinal classification (MVOC), which learns from different views (complexity, coupling, cohesion, inheritance and scale) of the software dataset separately and predicts software bugs taking the inherent order of class labels (non‐buggy, less buggy and more buggy) into consideration. To demonstrate its prediction performance, the MVOC approach was executed on the 40 different real‐world software datasets using six different classification algorithms as base learners. In the experiments, the MVOC approach was compared with traditional classifiers and their multi‐view implementations in terms of precision, recall, f‐measure and accuracy rate metrics. The results indicate that the MVOC approach presents better prediction performance on average than the multi‐view‐based and traditional classifiers. It is also observed from the results that the MVOC.RF model achieved the highest classification performance with an average accuracy rate of 85.65%. [ABSTRACT FROM AUTHOR]

Software Defect Prediction (SDP) involves the early detection of fault-prone modules and reduces the testing efforts and cost. Support Vector Machine (SVM)-based SDP classifiers use large amount of high-dimensional data, and hence feature selection (FS) is applied for better accuracy. Search-based feature selection is found effective to improve the efficiency of predictors. This paper proposes a genetic evolution (GeEv) technique to select features. The GeEv technique involves introduction of diversity at intermediate level by the genetic evolution of random offspring with better survival capability. GeEv searches the feature space for an optimal feature subset using the performance of classification and number of features selected as the fitness function. The FS is modeled as an optimization problem and optimal solution is sought using GeEv. The performance is compared with baseline technique. From the experimental results, it is shown GeEv outperforms the competing FS approach and can achieve better accuracy than others statistically. [ABSTRACT FROM AUTHOR]

Good data curation is integral to cohort studies, but it is not always done to a level necessary to ensure the longevity of the data a study holds. In this opinion paper, we introduce the concept of data curation debt-the data curation equivalent to the software engineering principle of technical debt. Using the context of UK cohort studies, we define data curation debt-describing examples and their potential impact. We highlight that accruing this debt can make it more difficult to use the data in the future. Additionally, the long-running nature of cohort studies means that interest is accrued on this debt and compounded over time-increasing the impact a debt could have on a study and its stakeholders. Primary causes of data curation debt are discussed across three categories: longevity of hardware, software and data formats; funding; and skills shortages. Based on cross-domain best practice, strategies to reduce the debt and preventive measures are proposed-with importance given to the recognition and transparent reporting of data curation debt. Describing the debt in this way, we encapsulate a multi-faceted issue in simple terms understandable by all cohort study stakeholders. Data curation debt is not only confined to the UK, but is an issue the international community must be aware of and address. This paper aims to stimulate a discussion between cohort studies and their stakeholders on how to address the issue of data curation debt. If data curation debt is left unchecked it could become impossible to use highly valued cohort study data, and ultimately represents an existential risk to studies themselves. [ABSTRACT FROM AUTHOR]

In software engineering, composition is the way to reuse existing work. In component-based development (CBD), a number of component models are defined with an emphasis on composition mechanisms for components. With respect to components, current component models can be categorised into three main groups where components are: (i) objects, (ii) architectural units and (iii) encapsulated components. This paper presents a comparison of system construction in these three categories of component models and concludes selecting the X-MAN component model (X-MAN) from the third category for its edge over other models because of its exogenous composition connectors. However, because of the limitations of X-MAN, the use of this component model at a wider scale is hindered. In this paper, we propose extended X-MAN component model (EX-MAN) which addresses the limitations of X-MAN. To demonstrate the EX-MAN semantics for system construction, we have developed a tool exogenous composition framework (ECF). We have described the concepts used in our work using a trivial bank example. To evaluate the feasibility of EX-MAN for system construction, using ECF (a related tool we have developed), we constructed the trivial bank example and also a more complex system, CoCoME, example. [ABSTRACT FROM AUTHOR]

The quality of software projects is measured by different attributes such as efficiency, security, robustness, or understandability, among others. In this paper, we focus on maintainability by studying the optimization of software modularity, which is one of the most important aspects in this regard. Specifically, we study two well-known and closely related multi-objective optimization problems: the Equal-size Cluster Approach Problem (ECA) and the Maximizing Cluster Approach Problem (MCA). Each of these two problems looks for the optimization of several conflicting and desirable objectives in terms of modularity. To this end, we propose a method based on the Multi-Objective Variable Neighborhood Search (MO-VNS) methodology in combination with a constructive procedure based on Path-Relinking. As far as we know, this is the first time that a method based on MO-VNS is proposed for the MCA and ECA problems. To enhance the performance of the proposed algorithm, we present three advanced strategies: an incremental evaluation of the objective functions, an efficient exploration of promising areas in the search space, and an analysis of the objectives that better serve as guiding functions during the search phase. Our proposal has been validated by experimentally comparing the performance of our algorithm with the best previous state-of-the-art method for the problem and three reference methods for multi-objective optimization. The experiments have been performed on a set of 124 real software instances previously reported in the literature. [ABSTRACT FROM AUTHOR]

This document is a guest editorial for a special issue of the journal "Programming & Computer Software" titled "Recent Trends on Advanced Computing: The Converging Technologies." The issue features research and practical implementation results from researchers and industry experts in computer science, engineering, and technology. The papers cover a range of topics including microservices, software quality, user engagement on social media, non-functional requirements, medical software architecture, fallacies in political speeches, intelligent learning environments, and more. The guest editors for this special issue are Prof. Dr. Andrei Tchernykh, Prof. Reyes Juárez Ramírez, Dr. Esteban Mocskos, and Prof. Sergio Nesmachnow. [Extracted from the article]

This paper presents ThreadAbs , an extension of the layer-based software formal verification toolkit CCAL (Gu et al., 2018). ThreadAbs is specifically designed to provide better expressiveness and proof management for thread abstraction in multithreaded libraries. Thread abstraction isolates the behavior of each thread from others when providing a top-level formal specification for software. Compared to the original CCAL , ThreadAbs offers significant improvements in this regard. CCAL is a verification framework that enables a layered approach to building certified software, as demonstrated by multiple examples (Gu et al. 2016; Li et al. 2021; Shin et al. 2019). Obviously, its main targets usually include multithread libraries, which support significant improvement in the utilization and isolation of system resources. However, it poses new challenges for formal verification. Firstly, it requires a sudden change in the granularity of concurrency during the implementation and verification of the target software. Typically, systems are associated with software schedulers that are built on top of several underlying components in the system (e.g. , thread spawn, yield, sleep, and wake-up). Due to the software scheduler, these systems can be divided into low-level components consisting of modules that the software scheduler depends on (e.g. , allocators for shared resources and scheduling queues) and high-level components that use software schedulers (e.g. , condition variables, semaphores, and IPCs). Therefore, software formal verification on those systems has to provide proper method to deal with those distinct features, which is usually abstracting other threads' behavior as much as possible to provide an independent thread model and its formal specification. Secondly, it requires handling side effects from other threads, such as dynamic resource allocation from parents with proper isolation of all threads from each other. CCAL has limited support for two crucial aspects of formal verification in multithreaded systems. Firstly, its previous thread abstraction method does not handle the side effects caused by a parent thread during dynamic initial state allocation properly. Secondly, the proofs produced by CCAL are tied to CertiKOS , which makes it challenging to use them for similar proofs that use CCAL as their verification toolkit. To address these issues, we introduce ThreadAbs , a new mechanized methodology that provides proper thread abstraction to reason about multithreaded programs in conjunction with CCAL. We also extend the previous CertiKOS proof with ThreadAbs to demonstrate its usability and expressiveness. [ABSTRACT FROM AUTHOR]

Background: Personal health data (PHD) research has been intensified over the last years, attracting the attention of scientists from different fields, such as software engineers, computer scientists and medical professionals. The increasing interest of researchers can be attributed to the exponential growth of the available PHD due to the widespread adoption of ubiquitous technology in everyday life, as well as to the potential of the ongoing digital transformation in healthcare. This increasing interest requires that academia has an overview of the published scientific literature to plan future endeavors.Objective: The main objective of this study is to identify and address research gaps in literature regarding PHD.Method: This paper conducts a systematic mapping study to summarize the existing PHD approaches in literature and to organize the selected studies according to six classification criteria: publication source, publication year, research types, empirical types, contribution types and research topic.Results: In total 79 papers have been included after fulfilling the inclusion criteria and have been classified accordingly. There is an increasing amount of attention that has been paid to PHD since 2014. The majority of papers is published in journals. The two main research types found were solution proposals and evaluation research. The majority of the selected papers were empirically evaluated. The main contribution types were methods and frameworks. Data privacy is the most frequently addressed topic in PHD literature, followed by data sharing.Conclusions: The findings of this systematic mapping study have implications for both researchers who are planning new studies in PHD and for practitioners who are working in connected health and would like to have an overview on the existent studies on PHD research area. [ABSTRACT FROM AUTHOR]

In this full review paper, the recent emerging trends in Computing Structures, Software Science, and System Applications have been reviewed and explored to address the recent topics and contributions in the era of the Software and Computing fields. This includes a set of rigorously reviewed world-class manuscripts addressing and detailing state-of-the-art, framework, implemented approaches and techniques research projects in the areas of Software Technology & Automation, Networking, Systems, Computing Sciences and Software Engineering, Big Data and E-learning. Based on this systematic review, we have put some recommendations and suggestions for researchers, practitioners and scholars to improve their research quality in this area. [ABSTRACT FROM AUTHOR]

The availability of open source assets for almost all imaginable domains has led the software industry to opportunistic design—an approach in which people develop new software systems in an ad hoc fashion by reusing and combining components that were not designed to be used together. In this paper we investigate this emerging approach. We demonstrate the approach with an industrial example in which Node.js modules and various subsystems are used in an opportunistic way. Furthermore, to study opportunistic reuse as a phenomenon, we present the results of three contextual interviews and a survey with reuse practitioners to understand to what extent opportunistic reuse offers improvements over traditional systematic reuse approaches. [ABSTRACT FROM AUTHOR]

Organisational learning is an area that aids organisations in improving their processes by reusing experience so that knowledge is accessible to the entire organisation. However, it is not a trivial task to bring about such learning in software development companies, especially as this is an area where processes and knowledge are often internalised in the minds of employees. Some approaches presented in the literature to facilitate organisational learning aim at transforming content generated within companies with Web 2.0 collaborative tools in courses. These courses are based on learning schema that describes their structure and content. However, the creation of these schemes requires a specialist who knows the company's needs as well as the pedagogical organisation's learning requirements. In order to facilitate learning and minimise dependence on specialists, this paper presents an approach that aims to aid companies in identifying developers' learning needs while creating learning schema in a semiautomatic way. Based on the approach proposed, an environment was implemented and an experimental study was conducted to evaluate the identification of relevant issues to the organisation and development of courses. Results suggest that this approach is feasible for discovering themes and creating in-company courses. [ABSTRACT FROM AUTHOR]

Scientific discovery increasingly relies on computation through simulations, analytics, and machine and deep learning. Of these, simulations on high-performance computing (HPC) platforms have been the cornerstone of scientific computing for more than two decades. However, the development of simulation software has, in general, occurred through accretion, with a few exceptions. With an increase in scientific understanding, models have become more complex, rendering an accretion mode untenable to the point where software productivity and sustainability have become active concerns in scientific computing. In this survey paper, we examine a modest set of HPC scientific simulation applications that are already using cutting-edge HPC platforms. Several have been in existence for a decade or more. Our objective in this survey is twofold: first, to understand the landscape of scientific computing on HPC platforms in order to distill the currently scattered knowledge about software practices that have helped both developer and software productivity, and second, to understand the kind of tools and methodologies that need attention for continued productivity. [ABSTRACT FROM AUTHOR]

This paper introduces a nature-inspired optimized algorithm called modified moth-flame optimization (MMFO) for usability feature selection. To determine quality of software usability plays a significant role. This model contains various usability factors that are divided into several features, which have some characteristics, thus making a hierarchical model. Here, the authors have introduced MMFO (Modified Moth-flame optimization algorithm) for the selection of usability features to get an optimal solution MMFO is an extension of moth-flame optimization algorithm (MFO), which is based on the navigation method of moths called transverse orientation and to the best of our knowledge; this algorithm is introduced in software engineering practices. The selected features and accuracy of proposed MMFO is compared with the original MFO and other related optimization techniques. The results shows that the proposed nature-inspired optimization algorithm outperforms the other related optimizers as it generates a fewer number of selected features and having low accuracy. [ABSTRACT FROM AUTHOR]

In this paper, we present an analysis of more than 500K comments from open-source repositories of software systems. Our aim is to empirically determine how developers interact with each other under certain psychological conditions generated by politeness, sentiment and emotion expressed within developers' comments. Developers involved in an open-source projects do not usually know each other; they mainly communicate through mailing lists, chat rooms, and tools such as issue tracking systems. The way in which they communicate affects the development process and the productivity of the people involved in the project. We evaluated politeness, sentiment and emotions of comments posted by developers and studied the communication ow to understand how they interacted in the presence of impolite and negative comments (and vice versa). Our analysis shows that when in presence of impolite or negative comments, the probability of the next comment being impolite or negative is 14% and 25%, respectively; anger however, has a probability of 40% of being followed by a further anger comment. The result could help managers take control the development phases of a system, since social aspects can seriously affect a developer's productivity. In a distributed environment this may have a particular resonance. [ABSTRACT FROM AUTHOR]

In software engineering, optimal feature selection for software product lines (SPLs) is an important and complicated task, involving simultaneous optimization of multiple competing objectives in large but highly constrained search spaces. A feature model is the standard representation of features of all possible products as well as the relationships among them for an SPL. Recently, various multi-objective evolutionary algorithms have been used to search for valid product configurations. However, the issue of the balance between correctness and diversity of solutions obtained in a reasonable time has been found very challenging for these algorithms. To tackle this problem, this paper proposes a novel aggregation-based dominance (ADO) for Pareto-based evolutionary algorithms to direct the search for high-quality solutions. Our method was tested on two widely used Pareto-based evolutionary algorithms: NSGA-II and SPEA2+SDE and validated on nine different SPLs with up to 10,000 features and two real-world SPLs with up to 7 objectives. Our experiments have shown the effectiveness and efficiency of both ADO-based NSGA-II and SPEA2+SDE: (1) Both algorithms could generate 100% valid solutions for all feature models. (2) The performance of both algorithms was improved as measured by the hypervolume metric in 7/9 and 8/9 feature models. (3) Even for the largest tested feature model with 10,000 features, it required under 40 s on a standard desktop to find 100% valid solutions in a single run of both algorithms. [ABSTRACT FROM AUTHOR]

Background: Randomized controlled clinical trials require management effort, involving huge organizational, economic and informatics investments. Information technology offers opportunities to approach clinical trial methodology in new ways. However, there are only a few reports of computerized data and drug management systems. Objective: This paper describes a novel software created specifically for the management of a randomized trial of diet and metformin in people with metabolic syndrome (the Me.Me.Me. trial). Methods: Me.Me.Me. is an ongoing phase III randomized controlled trial in healthy people with metabolic syndrome to test the hypothesis that comprehensive lifestyle changes and/or metformin can prevent age-related chronic non-communicable diseases. To manage all the phases of the trial, we created a software which is a state pattern machine, user friendly, web-based, able to maintain the correct balance between randomization groups, and structured in various levels of security in order to guarantee the participant’s privacy and compliance with the study protocol. The software achieves budget savings: drug management is not based on patients’ packs, but on the actual need for drugs according to each participant’s “state”, with strict guidelines for the handling and supply of medication. Results: The trial is ongoing and recruitment will close on August 31, 2018. To date, 11737 bottles of metformin/placebo have been dispensed to 1054 randomized participants, with drug savings of 29.5%. Conclusions: A software which takes into account the “state” of participant might be a powerful resource for developing and managing clinical trials, helping avoid poor treatment allocation, and wastage of drugs and money. Me.Me.Me. trial: EUDRACT no. . ClinicalTrials.gov Identifier: . [ABSTRACT FROM AUTHOR]

Purpose: The aim of this paper is to show how a specialized planning and guidance application called Fraxinus, can be built on top of the CustusX platform (), which is an open source image-guided intervention software platform. Fraxinus has been customized to meet the clinical needs in navigated bronchoscopy. Methods: The application requirements for Fraxinus were defined in close collaboration between research scientists, software developers and clinicians (pulmonologists), and built on top of CustusX. Its superbuild system downloads specific versions of the required libraries and builds them for the application in question, including the selected plugins. New functionality is easily added through the plugin framework. The build process enables the creation of specialized applications, adding additional documentation and custom configurations. The toolkit’s libraries offer building blocks for image-guided applications. An iterative development process was applied, where the clinicians would test and provide feedback during the entire process. Results: Fraxinus has been developed and is released as an open source planning and guidance application built on top of CustusX. It is highly specialized for bronchoscopy. The proposed workflow is adapted to the different steps in this procedure. The user interface of CustusX has been modified to enhance information, quality assurance and user friendliness with the intention to increase the overall yield for the patient. As the workflow of the procedure is relatively constant, some actions are predicted and automatically performed by the application, according to the requirements from the clinicians. Conclusions: The CustusX platform facilitates development of new and specialized applications. The toolkit supports the process and makes important extension and injection points available for customization. [ABSTRACT FROM AUTHOR]

Effort-aware just-in-time (JIT) defect prediction is to rank source code changes based on the likelihood of detects as well as the effort to inspect such changes. Accurate defect prediction algorithms help to find more defects with limited effort. To improve the accuracy of defect prediction, in this paper, we propose a deep learning based approach for effort-aware just-in-time defect prediction. The key idea of the proposed approach is that neural network and deep learning could be exploited to select useful features for defect prediction because they have been proved excellent at selecting useful features for classification and regression. First, we preprocess ten numerical metrics of code changes, and then feed them to a neural network whose output indicates how likely the code change under test contains bugs. Second, we compute the benefit cost ratio for each code change by dividing the likelihood by its size. Finally, we rank code changes according to their benefit cost ratio. Evaluation results on a well-known data set suggest that the proposed approach outperforms the state-of-the-art approaches on each of the subject projects. It improves the average recall and popt by 15.6% and 8.1%, respectively. [ABSTRACT FROM AUTHOR]

This paper provides a real example of applying COCOMO II as an estimation technique for the required software development effort in a safety-critical software application project following the DO-178C processes. The main goal and contribution of the case study is to support the research on software effort estimation and to provide software practitioners with useful data based on a real project. We applied the method as it is, by correlating the effort multiplier factors with the complexity and objectives introduced by the DO-178C level A application, resulting in an estimated effort. The rationales for each scale factor and effort multiplier selection were also described in detail. By comparing the estimated values with the actual required data, we found a magnitude of relative error (MRE) of 40% and provided alternatives for future work in order to increase the effort estimation accuracy in safety-critical software projects. [ABSTRACT FROM AUTHOR]

As sequencing prices drop, genomic data accumulates—seemingly at a steadily increasing pace. Most genomic data potentially have value beyond the initial purpose—but only if shared with the scientific community. This, of course, is often easier said than done. Some of the challenges in sharing genomic data include data volume (raw file sizes and number of files), complexities, formats, nomenclatures, metadata descriptions, and the choice of a repository. In this paper, we describe 10 quick tips for sharing open genomic data. [ABSTRACT FROM AUTHOR]

This paper presents an open-source package developed in Python that controls and drives a programmable Josephson array to synthesize dc and ac quantum-accurate voltages. Programmable arrays are devices subdivided into independent subsections, each counting a number of series connected Josephson junctions that follows a binary sequence (1, 2, 4, 8, …) to control the output voltage. Our software allows to independently measure the current-voltage characteristics of each subsection by means of a set of arbitrary waveform generators and a nanovoltmeter that measures the voltage across the whole array with high sensitivity. A quantization test tool is also provided to check with sub-microvolt resolution whether the array is operating on its quantum margins. The code is modular and easily expandable with the support of many libraries, allowing prompt reconfiguration for different calibration and testing purposes. It is aimed at being a starting point for cooperation between National Metrology Institutes towards the realization of a shared quantum voltage calibration infrastructure. [ABSTRACT FROM AUTHOR]

In recent years, misconfigurations have become one of the major causes of software system failures, resulting in numerous service outages. What is worse, misconfigurations are also costly to diagnose and troubleshoot. This remains a great challenge for sysadmins (system administrators) to detect, diagnose, or troubleshoot these misconfigurations. Unlike software bugs, misconfigurations are more vulnerable to sysadmins’ mistakes. Developers and researchers are attempting to improve system reactions to misconfigurations to ease the burden of sysadmins’ diagnoses. Such efforts would greatly benefit from the techniques that can comprehensively detect bad system reactions through injected misconfigurations. Unfortunately, few such studies have achieved the above goal in the past, primarily because they only relied on generic alterations and failed to find a way to systematically generate misconfigurations. In this paper, we study eight mature open-source and commercial software packages and summarize a fine-grained classification of option types. Based on this classification, we use Augmented Backus–Naur Form to summarize and extract syntactic and semantic constraints of each type. In order to generate comprehensive misconfigurations in the test systems, we propose misconfiguration generation methods for our constraints. We implement a tool named Configuration Vulnerability Detector (ConfVD) to conduct misconfiguration injection and further analyze the systems’ reaction abilities to various misconfigurations. We carried out comprehensive analyses upon Apache Httpd, MySQL, PostgreSQL, and Yum. The results of our analysis show that our option classification covers 96% of 1582 options from the above-mentioned systems. Our constraints are more fine grained than previous works and their accuracy was found to be 91% (ascertained by manual verification). Our technique could improve generic alteration approaches without constraints, and we found that ConfVD could find nearly three times the bad reactions that were found by ConfErr. In total, we found 65 bad reactions from the systems being tested and our fine-grained constraints contributed 27.7% more bad reactions than techniques only using coarse-grained constraints. [ABSTRACT FROM AUTHOR]

Architectural synthesis is a key phase of the conceptual design process. In the constant evolution of complex systems, architects have found it difficult to carry out an exhaustive search of all the feasible architectural solutions for a set of given requirements. This paper proposes a computational synthesis framework that automatically generates, from a set of formatted requirements and a sub-systems database, all architectures that are requirement consistent, minimalist regarding the number of components and non-redundant. The resolution principles are based on graph theory representations and Constraint Programming solving techniques. Key features of the framework and an application example are also detailed. Abbreviations: AO: architectural object; BPMN: business process model and notation; CSP: constraint satisfaction problem; DSM: design structure matrix; SE: systems engineering. [ABSTRACT FROM AUTHOR]

In the past decades, there has been a burst of activity to simplify implementation of complex software systems. The solution framework in software engineering community for this problem is called component-based software design (CBSD), whereas in the modeling and simulation community it is called composability. Composability is a complex feature due to the challenges of creating components, selecting combinations of components, and integrating the selected components. In this paper, we address the challenge through the analysis of Component Selection (CS), the NP-complete process of selecting a minimal set of components to satisfy a set of objectives. Due to the computational complexity of CS, we consider approximation algorithms that make the component selection process practical. We define three variations of CS and present good approximation algorithms to find near optimal solutions. In spite of our creation of approximable variants of Component Selection, we prove that the general Component Selection problem is inapproximable. [ABSTRACT FROM AUTHOR]

Performing the Systematic Literature Review (SLR) in the turbulent field of Software Engineering (SE) brings different obstacles and uncertainties. The commonly used guidelines for performing the SLR in this field are adapted from health sciences and presented by Kitchenham and Charters in 2007. This paper follows the Kitchenham's three-phases-review-process and fulfils it with the findings, observations and recommendations from other influential authors in the field. The process of SLR is observed from the perspective of appliance in the field of SE and supplemented by the important precautious measures that should be undertaken by the authors performing it. Thus, this paper aims to present the state-of-the-art in performing the SLR in SE. [ABSTRACT FROM AUTHOR]

With continued technology scaling and increased power and thermal densities, processor operation and performance are increasingly dominated by physical phenomena. Microarchitectural approaches to mitigate these effects must be based on a profound understanding of how the physics is manifested in microarchitectural executions and system-level properties, such as performance, energy efficiency, or lifetime reliability. This requires a modeling and simulation environment that incorporates multiple physical phenomena and their concurrent interactions with microarchitecture. In this paper, we introduce an integrated power, thermal, and reliability modeling framework, KitFox. The goal of KitFox framework is to facilitate research explorations at the intersection of applications, microarchitectures, and various physical phenomena, including energy, power, thermal, cooling, and reliability. The KitFox framework implements a standard interface to bridge multiple physical models, where individual models are encapsulated into libraries and are interchangeable. This paper describes the design methodology of the library framework that orchestrates various implementations of physical models and standardized interface to cycle-level microarchitecture simulators. Several use cases are presented to demonstrate the range of modeling capabilities of KitFox. [ABSTRACT FROM PUBLISHER]

Agent-oriented techniques represent an exciting new means of analyzing, designing and building complex software systems. They have the potential to significantly improve current practice in software engineering and to extend the range of applications that can feasibly be tackled. Yet, to date, there have been few serious attempts to cast agent systems as a software engineering paradigm. This paper seeks to rectify this omission. Specifically, points to be argued include:firstly, the conceptual apparatus of agent-oriented systems is well-suited to building software solutions for complex systems and secondly, agent-oriented approaches represent a genuine advance over the current state of the art for engineering complex systems. Following on from this view, the major issues raised by adopting an agentoriented approach to software engineering are highlighted and discussed in this paper. [ABSTRACT FROM AUTHOR]

Requirements engineering (RE) has attracted a great deal of attention from researchers and practitioners in recent years. Requirements engineering education (REE) is therefore an important undertaking if the field is to have professionals who are capable of successfully accomplishing software projects. This increasing interest demands that academia should provide software engineering students with a solid foundation in the subject matter. This paper aims to identify and to present the current research on REE that is available at present, and to select useful approaches and needs for future research. A systematic mapping study was therefore performed to classify the selected studies into five classification criteria: research type, empirical type, contribution type, RE activity, and curricula. A total of 79 papers were selected and classified according to these criteria. The results of this systematic mapping study are discussed, and a list of advice obtained from the REE literature for instructors is provided. [ABSTRACT FROM AUTHOR]

Modern bioinformatics and computational biology are fields of study driven by the availability of effective software required for conducting appropriate research tasks. Apart from providing reliable and fast implementations of different data analysis algorithms, these software applications should also be clear and easy to use through proper user interfaces, providing appropriate data management and visualization capabilities. In this regard, the user experience obtained by interacting with these applications via their Graphical User Interfaces (GUI) is a key factor for their final success and real utility for researchers. Despite the existence of different packages and applications focused on advanced data visualization, there is a lack of specific libraries providing pertinent GUI components able to help scientific bioinformatics software developers. To that end, this paper introduces GC4S, a bioinformatics-oriented collection of high-level, extensible, and reusable Java GUI elements specifically designed to speed up bioinformatics software development. Within GC4S, developers of new applications can focus on the specific GUI requirements of their projects, relying on GC4S for generalities and abstractions. GC4S is free software distributed under the terms of GNU Lesser General Public License and both source code and documentation are publicly available at [ABSTRACT FROM AUTHOR]

The Unified Process (UP) is a processes framework widely known and used by the software industry and academic community. UP was developed under the conception of a universal application, but even a single process is not appropriate to address all development projects since optimal process depends on the particularities of each project or organization. Frequently, many process components need to be adapted to the organization or project needs, a complex task because the experience and knowledge required. Perform adaptation in an inappropriate way is prone to error due to the difficulties for taking tailoring decisions. The paper goal is proposing a canonical software processes family based on the Unified Process to support software process tailoring. Our methodology was based on the meta-process CASPER to build a software process family and we use the Case Study method as a strategy for validating the canonical process family empirically. As a result, we show a canonical software processes family, which will serve as a platform for determining a process family based on Unified process in a small software organization. This canonical family has the advantage that uses a tailoring mechanism following a transformation strategy that encapsulates tailoring decisions in order to systematize this activity. In this work, we show the initial results in the applicability of a canonical software process family as base in the building the software process families based on UP in the small companies context, and also we conclude that the UP is a process framework with spread spectrum, which limited its formulation like a general software process family, due to that a process family requires determining carefully the application domain known as software process family scope. [ABSTRACT FROM AUTHOR]

Abstract: Evolvability of software lies in intersection of 3 factors: evolving system properties, human factors present in the developer team, and evolution demands. The paper presents 5 recommendations that enhance software evolvability: defined processes of software change, distinction between evolving and stabilized part of the code, analyzable code segments, significant concept encapsulation, and avoidance of wrapping. [ABSTRACT FROM AUTHOR]

Data mining and search-based algorithms have been applied to various problems due to their power and performance. There have been several studies on the use of these algorithms for refactoring. In this paper, we show how search based algorithms can be used for sequence diagram refactoring. We also show how a hybridized algorithm of Kmeans and Simulated Annealing (SA) algorithms can aid each other in solving sequence diagram refactoring. Results show that search based algorithms can be used successfully in refactoring sequence diagram on small and large case studies. In addition, the hybridized algorithm obtains good results using selected quality metrics. Detailed insights on the experiments on sequence diagram refactoring reveal that the limitations of SA can be addressed by hybridizing the Kmeans algorithm to the SA algorithm. [ABSTRACT FROM AUTHOR]

Microprocessors in safety-critical system are extremely vulnerable to hacker attacks and circuit crosstalk, as they can modify binaries and lead programs to run along the wrong control flow paths. It is a significant challenge to design a run-time validation method with few hardware modification. In this paper, an efficient control flow validation method named DCM (Dual-Processor Control Flow Validation Method) is proposed basing on dual-processor architecture. Since a burst of memory-access-intensive instructions could block pipeline and cause lots of waiting clocks, the DCM assigns the idle pipeline cycles of the blocked processor to the other processor to validate control flow at run time. An extra lightweight monitor unit in each processor is needed and a special dual-processor communication protocol is also designed to schedule the redundant computing capacity between two processors to do validation tasks better. To further improve the efficiency, we also design a software-based self-validation algorithm to help reduce validation times. The combination of both hardware method and software method can speed up the validation procedure and protect the control flow paths with different emphasis. The cycle-accurate simulator GEM5 is used to simulate two ARMv7-A processors with out-of-order pipeline. Experiment shows the performance overhead of DCM is less than 22% on average across the SPEC 2006 benchmarks. [ABSTRACT FROM AUTHOR]