Search

Software deffect prediction, a problem of major relevance within the search-based software engineering field, aims to enhance software quality by early and precisely uncovering faulty software modules. Accurate detection of software defects in new software releases might increase the performance of the software development process in terms of cost, time and software quality. Most approaches from the software deffect prediction literature try to develop general solutions that are designed to work with any type of software deffect. From a software engineering perspective, software defects may take various forms and identifying/fixing different types of defects requires different approaches. Starting from the assumption that specific types of software defects have a particular behaviour, we are introducing in this paper, as a proof of concept, an unsupervised learning-based methodology for mining behavioural patterns for specific classes of software defects and identifying features which would be relevant for detecting the uncovered classes. The experiments performed on an open-source software deffect prediction data set collected from all releases of the Apache Ivy software highlight that the results obtained by applying the proposed methodology are highly correlated with the way human domain experts categorise and address software defects. Creating software deffect prediction models that are specifically tailored for different software deffect types may improve the accuracy of the developed models, open the possibility to apply different sets of predictive models based on the domain of the software and may accelerate the adoption of software deffect prediction approaches by the industry. [ABSTRACT FROM AUTHOR]

ABSTRACT Despite the fact that software is mostly a team endeavor, the software engineering (SE) literature has not tapped into organizational psychology's conceptual and empirical writings on teams. This paper presents a model of team dynamics adapted to the specificities of SE project teams. The taxonomy is composed of nine episodes that are likely to be found in any software team process. Each episode is described in terms of the input-process-output cycle and illustrated with examples. The measurability of the episodes is validated on a capstone student project carried out with an industrial partner. The team activities are recorded by each developer, throughout the project's duration, in the form of work tokens. These work tokens are then associated with episodes by two independent coders. The results show that all the episodes of the proposed taxonomy are measurable, and very few (less than 5% in this field study) remain ambiguous. Most of the ambiguities arise from short episodes that alternate during team process activities. This paper's contribution to software team process research is to synthesize the team literature and draw up a theoretically driven taxonomy of team dynamics specific to SE teams and to provide initial evidence of measurability of the taxonomy. Copyright © 2014 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Entity recognition and extraction are the foundations of knowledge graph construction. Entity data in the field of software engineering come from different platforms and communities, and have different formats. This paper divides multi-source software knowledge entities into unstructured data, semi-structured data and code data. For these different types of data, Bi-directional Long Short- Term Memory (Bi-LSTM) with Conditional Random Field (CRF), template matching, and abstract syntax tree are used and integrated into a multi-source software knowledge entity extraction integration model (MEIM) to extract software entities. The model can be updated continuously based on user's feedbacks to improve the accuracy. To deal with the shortage of entity annotation datasets, keyword extraction methods based on Term Frequency-Inverse Document Frequency (TF-IDF), TextRank, and K-Means are applied to annotate tasks. The proposed MEIM model is applied to the Spring Boot framework, which demonstrates good adaptability. The extracted entities are used to construct a knowledge graph, which is applied to association retrieval and association visualization. [ABSTRACT FROM AUTHOR]

In software engineering predictive modeling, early prediction of software modules or classes that possess high maintainability effort is a challenging task. Many prediction models are constructed to predict the maintainability of software classes or modules by applying various machine learning (ML) techniques. If the software modules or classes need high maintainability, effort would be reduced in a dataset, and there would be imbalanced data to train the model. The imbalanced datasets make ML techniques bias their predictions towards low maintainability effort or majority classes, and minority class instances get discarded as noise by the machine learning (ML) techniques. In this direction, this paper presents empirical work to improve the performance of software maintainability prediction (SMP) models developed with ML techniques using imbalanced data. For developing the models, the imbalanced data is pre-processed by applying data resampling methods. Fourteen data resampling methods, including oversampling, undersampling, and hybrid resampling, are used in the study. The study results recommend that the safe-level synthetic minority oversampling technique (Safe-Level-SMOTE) is a useful method to deal with the imbalanced datasets and to develop competent prediction models to forecast software maintainability. [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]

In current digital era, software evolution is continuously put into practice by practitioners in order to meet up the changing stakeholder's requirements. It has been investigated that for success of any software system, requirements engineering is very critical phase. This brings an evolution in the scope of the requirements engineering process, along with novel challenges of managing the requirements. Requirements Engineering is considered as a collection of processes that functions on various levels, which incorporate at organizational, product and project level. This paper presents a comparative study of different requirements engineering process models. The objective of the study is to find the vital aspects that contribute to RE process model selection from the viewpoint of practitioners in the business. Several possible future directions for RE process in software engineering are presented, including application specific elicitation techniques, requirements pre-processing, requirements prioritization etc. [ABSTRACT FROM AUTHOR]

Requirements engineering is a fundamental part of the software engineering process. When the stakeholders of the software project disagree on the requirements, requirements negotiation methods can be used to reach that agreement. This avoids rework and extra costs. A number of new requirements negotiation methods are created by researchers over the last years. This paper provides a review on which negotiation method can be used under which circumstances. Such a review is relevant for both practitioners and researchers. Practitioners could use the results to make decisions on which method might be the best choice for their project contexts. To researchers, it would help them see trends in the requirements negotiation field. In this paper more attention is given to create new requirements negotiation methods than before and the methods also cover more types of requirement conflicts now than they did in the past. We also found that requirements contradiction conflicts and quality attribute conflicts are getting more attention now than they were getting before, while resource conflicts and feasibility conflicts still are getting almost no attention at all. Furthermore, we found that almost all requirements negotiation methods are suitable for resolving viewpoint conflicts. Finally, Theory W (WinWin approach) [2] is still very popular for use in the design of requirements negotiation methods. [ABSTRACT FROM AUTHOR]

Softwarization of networks allows simplifying deployment, configuration, and management of network functions. The driving force toward this evolution is represented by software defined networking that allows more flexible and dynamic network resource allocation and management. The efficient allocation and orchestration of network resources is of extreme importance for this softwarization process, and many centralized solutions have been proposed. However, they are complex and exhibit scalability issues. So, distributed solutions are to be preferred but, in order to be effective, should quickly converge towards equilibrium solutions. In this paper, we focus on making distributed resource allocation and orchestration a viable approach, and prove convergence of the relevant mechanisms. Specifically, we exploit game theory to model interactions between users requesting network functions and servers providing these functions. Accordingly, a two-stage Stackelberg game is presented, where servers act as leaders of the game and users as followers. Servers have conflicting interests and try to maximize their utility; users, on the other hand, use a replicator behavior and try to imitate other user’s decisions to improve their benefit. The framework proves the existence and uniqueness of an equilibrium, and a learning mechanism to converge to such equilibrium is proposed. Numerical results show the effectiveness of the approach. [ABSTRACT FROM PUBLISHER]

The energy consumption of computer systems has become an important economic and environmental issue. Many researchers have focused on the energy consumption of hardware, but what about the software? Software energy consumption is widely adopted for Green computation of practical experimentation in research laboratories. But current researchers fail to build a consistent concept base for software energy consumption of critical applications. While branch coverage and concolic testing are very critical practices to validate the safety critical systems, very little effort is given to measure their energy consumption. The computation of the energy consumption of these techniques is an important issue in Green IT and Green Software Engineering. The contribution of this paper is to automate the computation and analysis of the energy consumption of the testing technique while enhancing the branch coverage using concolic testing. We implement our proposed automation framework in a tool, named Green Analysis of Branch Coverage Enhancement. The empirical study with forty Java programs and the evaluation results show that our developed tool achieves an average increase of 13.5 % in branch coverage. The average energy consumption of our automated tool is approximately 5.6 kJ to compute the branch coverage for all the forty experimental programs. [ABSTRACT FROM AUTHOR]

Fault localization is one of the most important and difficult tasks in the software debugging process. Therefore, several methods have been proposed to automate and improve this process. Mutation-based fault localization is one of the states of the art techniques that try to locate faults by executing different mutants of the faulty program. In addition to favorable results, it is along with a massive increase in mutation execution cost. In this paper, we propose a new mutation-based fault localization approach called SMBFL, that aim to reduce the execution cost by reducing the number of statements to be mutated. As fewer mutants execute with SMBFL, the whole process will become faster and the cost will decrease. SMBFL only examines the statements in the dynamic slice of the program under test. The statements that present in the dynamic slice have a direct effect on the execution of the program with the specified test case. In the SMBFL method, the suspiciousness score of program statements is measured based on the entropy of their mutants. The proposed formula, MuEn, determines the suspiciousness score based on the result of executing mutants of each statement of the program. SMBFL is evaluated during a series of tests. The results show a relative increase in the accuracy of fault localization, by an average of 14.2%, and a decrease in the execution time of the fault localization process, by an average of 24.3%. Finally, the MuEn formula applies the least execution overhead to the fault localization process. [ABSTRACT FROM AUTHOR]

In this paper, we base our research on a fictional collective programming scenario: A group of physically-distributed programmers try to collaboratively solve a programming problem in a web-based development environment, through a continually executing loop, consisting of three concurrent activities: exploration, integration, and feedback. In exploration, a programmer is freely to submit a sequence of gradually improved solutions until achieving a correct one. All programmers' latest submissions are integrated into a collective artifact through integration. And through feedback, any programmer who hasn't achieved a correct solution is continuously pushed with personalized feedback information from the collective artifact, to help the programmer improve her/his submission. In order to facilitate the realization of this fictional scenario, we narrow the target problems to those introductory programming problems, design a genetic algorithm to integrate a set of syntax-correct programs into a collective program dependence graph (CPDG), and propose an automatic feedback generation method based on the CPDG and a programmer's latest submission. The key idea is to generate feedback from mutual inspiration: Any programmer's submission (even not correct) may possess information that could provide inspiration for others. We evaluate the proposed approach through a set of simulated experiments, as well as a set of real experiments. The results show that our approach has a precision of 90% and a recall of 80% in randomly generated data sets on average, and a precision of 69% and a recall of 77% in real student submissions on average. [ABSTRACT FROM AUTHOR]

Context: The 'as code' suffix in infrastructure as code (IaC) refers to applying software engineering activities, such as version control, to maintain IaC scripts. Without the application of these activities, defects that can have serious consequences may be introduced in IaC scripts. A systematic investigation of the development anti-patterns for IaC scripts can guide practitioners in identifying activities to avoid defects in IaC scripts. Development anti-patterns are recurring development activities that relate with defective IaC scripts. Goal: The goal of this paper is to help practitioners improve the quality of infrastructure as code (IaC) scripts by identifying development activities that relate with defective IaC scripts. Methodology: We identify development anti-patterns by adopting a mixed-methods approach, where we apply quantitative analysis with 2,138 open source IaC scripts and conduct a survey with 51 practitioners. Findings: We observe five development activities to be related with defective IaC scripts from our quantitative analysis. We identify five development anti-patterns namely, 'boss is not around', 'many cooks spoil', 'minors are spoiler', 'silos', and 'unfocused contribution'. Conclusion: Our identified development anti-patterns suggest the importance of 'as code' activities in IaC because these activities are related to quality of IaC scripts. [ABSTRACT FROM AUTHOR]

This paper analyzes the phenomenon of software aging – namely, the gradual performance degradation and resource exhaustion in the long run – in the Android OS. The study intends to highlight if, and to what extent, devices from different vendors, under various usage conditions and configurations, are affected by software aging and which parts of the system are the main contributors. The results demonstrate that software aging systematically determines a gradual loss of responsiveness perceived by the user, and an unjustified depletion of physical memory. The analysis reveals differences in the aging trends due to the workload factors and to the type of running applications, as well as differences due to vendors' customization. Moreover, we analyze several system-level metrics to trace back the software aging effects to their main causes. We show that bloated Java containers are a significant contributor to software aging, and that it is feasible to mitigate aging through a micro-rejuvenation solution at the container level. [ABSTRACT FROM AUTHOR]

For several years, the software engineering research community used eye trackers to study program comprehension, bug localization, pair programming, and other software engineering tasks. Eye trackers provide researchers with insights on software engineers' cognitive processes, data that can augment those acquired through other means, such as on-line surveys and questionnaires. While there are many ways to take advantage of eye trackers, advancing their use requires defining standards for experimental design, execution, and reporting. We begin by presenting the foundations of eye tracking to provide context and perspective. Based on previous surveys of eye tracking for programming and software engineering tasks and our collective, extensive experience with eye trackers, we discuss when and why researchers should use eye trackers as well as how they should use them. We compile a list of typical use cases—real and anticipated—of eye trackers, as well as metrics, visualizations, and statistical analyses to analyze and report eye-tracking data. We also discuss the pragmatics of eye tracking studies. Finally, we offer lessons learned about using eye trackers to study software engineering tasks. This paper is intended to be a one-stop resource for researchers interested in designing, executing, and reporting eye tracking studies of software engineering tasks. [ABSTRACT FROM AUTHOR]

Software defect prediction is a research hotspot in the field of software engineering. However, due to the limitations of current machine learning algorithms, we can't achieve good effect for defect prediction by only using machine learning algorithms. In previous studies, some researchers used extreme learning machine (ELM) to conduct defect prediction. However, the initial weights and biases of the ELM are determined randomly, which reduces the prediction performance of ELM. Motivated by the idea of search based software engineering, we propose a novel software defect prediction model named KAEA based on kernel principal component analysis (KPCA), adaptive genetic algorithm, extreme learning machine and Adaboost algorithm, which has three main advantages: (1) KPCA can extract optimal representative features by leveraging a nonlinear mapping function; (2) We leverage adaptive genetic algorithm to optimize the initial weights and biases of ELM, so as to improve the generalization ability and prediction capacity of ELM; (3) We use the Adaboost algorithm to integrate multiple ELM basic predictors optimized by adaptive genetic algorithm into a strong predictor, which can further improve the effect of defect prediction. To effectively evaluate the performance of KAEA, we use eleven datasets from large open source projects, and compare the KAEA with four machine learning basic classifiers, ELM and its three variants. The experimental results show that KAEA is superior to these baseline models in most cases. [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]

Finding and fixing buggy code is an important and cost-intensive maintenance task, and static analysis (SA) is one of the methods developers use to perform it. SA tools warn developers about potential bugs by scanning their source code for commonly occurring bug patterns, thus giving those developers opportunities to fix the warnings (potential bugs) before they release the software. Typically, SA tools scan for general bug patterns that are common to any software project (such as null pointer dereference), and not for project specific patterns. However, past research has pointed to this lack of customizability as a severe limiting issue in SA. Accordingly, in this paper, we propose an approach called Ammonia, which is based on statically analyzing changes across the development history of a project, as a means to identify project-specific bug patterns. Furthermore, the bug patterns identified by our tool do not relate to just one developer or one specific commit, they reflect the project as a whole and compliment the warnings from other SA tools that identify general bug patterns. Herein, we report on the application of our implemented tool and approach to four Java projects: Ant, Camel, POI, and Wicket. The results obtained show that our tool could detect 19 project specific bug patterns across those four projects. Next, through manual analysis, we determined that six of those change patterns were actual bugs and submitted pull requests based on those bug patterns. As a result, five of the pull requests were merged. [ABSTRACT FROM AUTHOR]

A recent research showed that mobile apps represent nowadays 75% of the whole usage of mobile devices. This means that the mobile user experience, while tied to many factors (e.g., hardware device, connection speed, etc.), strongly depends on the quality of the apps being used. With "quality" here we do not simply refer to the features offered by the app, but also to its non-functional characteristics, such as security, reliability, and performance. This latter is particularly important considering the limited hardware resources (e.g., memory) mobile apps can exploit. In this paper, we present the largest study at date investigating performance bugs in mobile apps. In particular, we (i) define a taxonomy of the types of performance bugs affecting Android and iOS apps; and (ii) study the survivability of performance bugs (i.e., the number of days between the bug introduction and its fixing). Our findings aim to help researchers and apps developers in building performance-bugs detection tools and focusing their verification and validation activities on the most frequent types of performance bugs. [ABSTRACT FROM AUTHOR]

Software repositories contain a plethora of useful information that can be used to enhance software projects. Prior work has leveraged repository data to improve many aspects of the software development process, such as, help extract requirement decisions, identify potentially defective code and improve maintenance and evolution. However, in many cases, project stakeholders are not able to fully benefit from their software repositories due to the fact that they need special expertise to mine their repositories. Also, extracting and linking data from different types of repositories (e.g., source code control and bug repositories) requires dedicated effort and time, even if the stakeholder has the expertise to perform such a task. Therefore, in this paper, we use bots to automate and ease the process of extracting useful information from software repositories. Particularly, we lay out an approach of how bots, layered on top of software repositories, can be used to answer some of the most common software development/maintenance questions facing developers. We perform a preliminary study with 12 participants to validate the effectiveness of the bot. Our findings indicate that using bots achieves very promising results compared to not using the bot (baseline). Most of the participants (90.0%) find the bot to be either useful or very useful. Also, they completed 90.8% of the tasks correctly using the bot with a median time of 40 seconds per task. On the other hand, without the bot, the participants completed 25.2% of the tasks with a median time of 240 seconds per task. Our work has the potential to transform the MSR field by significantly lowering the barrier to entry, making the extraction of useful information from software repositories as easy as chatting with a bot. [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]

Logging is a common practice in software engineering. Prior research has investigated the characteristics of logging practices in system software (e.g., web servers or databases) as well as desktop applications. However, despite the popularity of mobile apps, little is known about their logging practices. In this paper, we sought to study logging practices in mobile apps. In particular, we conduct a case study on 1,444 open source Android apps in the F-Droid repository. Through a quantitative study, we find that although mobile app logging is less pervasive than server and desktop applications, logging is leveraged in almost all studied apps. However, we find that there exist considerable differences between the logging practices of mobile apps and the logging practices in server and desktop applications observed by prior studies. In order to further understand such differences, we conduct a firehouse email interview and a qualitative annotation on the rationale of using logs in mobile app development. By comparing the logging level of each logging statement with developers' rationale of using the logs, we find that all too often (35.4%), the chosen logging level and the rationale are inconsistent. Such inconsistency may prevent the useful runtime information to be recorded or may generate unnecessary logs that may cause performance overhead. Finally, to understand the magnitude of such performance overhead, we conduct a performance evaluation between generating all the logs and not generating any logs in eight mobile apps. In general, we observe a statistically significant performance overhead based on various performance metrics (response time, CPU and battery consumption). In addition, we find that if the performance overhead of logging is significantly observed in an app, disabling the unnecessary logs indeed provides a statistically significant performance improvement. Our results show the need for a systematic guidance and automated tool support to assist in mobile logging practices. [ABSTRACT FROM AUTHOR]

Behaviour models are the most commonly used input for predicting the reliability of a software system at the early design stage. A component behaviour model reveals the structure and behaviour of the component during the execution of system-level functionalities. There are various challenges related to component reliability prediction at the early design stage based on behaviour models. For example, most of the current reliability techniques do not provide fine-grained sequential behaviour models of individual components and fail to consider the loop entry and exit points in the reliability computation. Moreover, some of the current techniques do not tackle the problem of operational data unavailability and the lack of analysis results that can be valuable for software architects at the early design stage. This paper proposes a reliability prediction technique that, pragmatically, synthesizes system behaviour in the form of a state machine, given a set of scenarios and corresponding constraints as input. The state machine is utilized as a base for generating the component-relevant operational data. The state machine is also used as a source for identifying the nodes and edges of a component probabilistic dependency graph (CPDG). Based on the CPDG, a stack-based algorithm is used to compute the reliability. The proposed technique is evaluated by a comparison with existing techniques and the application of sensitivity analysis to a robotic wheelchair system as a case study. The results indicate that the proposed technique is more relevant at the early design stage compared to existing works, and can provide a more realistic and meaningful prediction. [ABSTRACT FROM AUTHOR]

Evaluation of search engines relies on assessments of search results for selected test queries, from which we would ideally like to draw conclusions in terms of relevance of the results for general (e.g., future, unknown) users. In practice however, most evaluation scenarios only allow us to conclusively determine the relevance towards the particular assessor that provided the judgments. A factor that cannot be ignored when extending conclusions made from assessors towards users, is the possible disagreement on relevance, assuming that a single gold truth label does not exist. This paper presents and analyzes the predicted relevance model (PRM), which allows predicting a particular result's relevance for a random user, based on an observed assessment and knowledge on the average disagreement between assessors. With the PRM, existing evaluation metrics designed to measure binary assessor relevance, can be transformed into more robust and effectively graded measures that evaluate relevance towards a random user. It also leads to a principled way of quantifying multiple graded or categorical relevance levels for use as gains in established graded relevance measures, such as normalized discounted cumulative gain, which nowadays often use heuristic and data-independent gain values. Given a set of test topics with graded relevance judgments, the PRM allows evaluating systems on different scenarios, such as their capability of retrieving top results, or how well they are able to filter out non-relevant ones. Its use in actual evaluation scenarios is illustrated on several information retrieval test collections. [ABSTRACT FROM AUTHOR]

Fuzzy systems have been used widely thanks to their ability to successfully solve a wide range of problems in different application fields. However, their replication and application require a high level of knowledge and experience. Furthermore, few researchers publish the software and/or source code associated with their proposals, which is a major obstacle to scientific progress in other disciplines and in industry. In recent years, most fuzzy system software has been developed in order to facilitate the use of fuzzy systems. Some software is commercially distributed, but most software is available as free and open-source software, reducing such obstacles and providing many advantages: quicker detection of errors, innovative applications, faster adoption of fuzzy systems, etc. In this paper, we present an overview of freely available and open-source fuzzy systems software in order to provide a well-established framework that helps researchers to find existing proposals easily and to develop well-founded future work. To accomplish this, we propose a two-level taxonomy, and we describe the main contributions related to each field. Moreover, we provide a snapshot of the status of the publications in this field according to the ISI Web of Knowledge. Finally, some considerations regarding recent trends and potential research directions are presented. [ABSTRACT FROM PUBLISHER]

Software has become part of all aspects of our lives, and organizations are increasingly conceiving extremely large and complex software projects. Agile development is a method of building software by empowering and trusting people, acknowledging change as norm, and promoting constant delivery of small pieces of working code. Yet, for large project, scaling Agile Scrum framework requires multi level management to coordinate the efforts and integrate the smaller pieces of the working code. An iterative paired Scrum framework is proposed to manage the development process of large project while exploiting the benefits of Agile methodology. Top-down requirement categorization and modulation is achieved to allow for the short cycle of the sprint in Agile Scrum framework. Requirement modularity while employing Scrum development methodology will, not only, help managing large project but also facilitating and acceleration its deployment. The different categories of the requirements constitute the Sprint modules, which iteratively reformed into production architecture. The objective of this research paper is to establish a framework model that pairs modularity with Scrum methodology. The framework employs three levels of process development and management to facilitate and minimize deployment efforts, without, compromising the agility characteristics of the Agile Scrum framework. [ABSTRACT FROM AUTHOR]

This paper aims to showcase a set of features which enables users to develop custom processing models using a specific interface for the workflow. The component presented in this paper, part of the ArcGIS software suite, is called ModelBuilder and allows a visual description of the processing flow, which enable users who do not have extensive programming knowledge to define custom processing models. The tool is also addressed for experienced programmers by having the ability to include scripts within the models and setting them parameters for integration with the workflow. This way, the models can be run either as stand-alone tools, on demand using specific interaction routines - GIS Add-ins, or can be embedded in WebGIS applications by exporting them as geoprocessing services and run through ArcGIS Server or through Cloud services provided by ESRI (the company that develops ArcGIS). [ABSTRACT FROM AUTHOR]

Edge computing is a continuum that includes the computing resources from cloud to things. Ecosystem of things (EoT) is a subsystem of the ecosystem of edge computing, which potentially contains trillions of devices of things and directly interacts with the physical world. This paper surveys the state of the art of EoT by focusing on the computing infrastructure aspect with a forward-looking perspective. We point out a trend of smart edge computing with four types of smartness and intelligence. We address three fundamental questions. 1) What capabilities and how much energy efficiency are the hardware providing? What is the future growth potential? 2) What abstractions are provided by the system software? Are they adequate to support smart edge computing? 3) What ecosystem architectures have been proposed for the coordination of things, the edge, and the cloud? Are they meeting the needs to encourage innovation but avoid unnecessary ecosystem fragmentation? We examine advances from both industry and academia, including research results, visions, and project concepts. We also point out future research directions. [ABSTRACT FROM AUTHOR]

This paper presents an automated model and a project, Arrakis, for finding defects in shading algorithms for graphics rendering and compute workloads. A key challenge in shading algorithm testing is the lack of an oracle that can determine the quality and the output of a custom shading algorithm; this is crucial in graphics workloads because expensive assets are often wasted on solving these problems. A broad solution, Arrakis is developed, which builds on current graphics technology advances in Vulkan, SPIR-V and SPIRV-X by leveraging the standardization with mappings from SPIR-V and C++. Findings show that utilizing the demonstrated technology can improve quality whilst increasing productivity. [ABSTRACT FROM AUTHOR]

Software process improvement (SPI) is an instrument to increase the productivity of, and the quality of work, in software organizations. However, a majority of SPI frameworks are too extensive or provide guidance and potential improvement areas at a high level, indicating only the symptoms, not the causes. Motivated by the industrial need of two Swedish automotive companies to systematically uncover the underlying root causes of high-level improvement issues identified in an SPI project—assessing inter-departmental interactions in large-scale software systems development—this paper advances a root cause analysis (RCA) method building on Lean Six Sigma, called Flex-RCA. Flex-RCA is used to delve deeper into challenges identified to find root causes as a part of the evaluation and subsequent improvement activities. We also demonstrate and evaluate Flex-RCA's industrial applicability in a case study. An overall conclusion is that the use of Flex-RCA was successful, showing that it had the desired effect of both producing a broad base of causes on a high level and, more importantly, enabling an exploration of the underlying root causes. [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]

When projects lack sufficient local data to make predictions, they try to transfer information from other projects. How can we best support this process? In the field of software engineering, transfer learning has been shown to be effective for defect prediction. This paper checks whether it is possible to build transfer learners for software effort estimation. We use data on 154 projects from 2 sources to investigate transfer learning between different time intervals and 195 projects from 51 sources to provide evidence on the value of transfer learning for traditional cross-company learning problems. We find that the same transfer learning method can be useful for transfer effort estimation results for the cross-company learning problem and the cross-time learning problem. It is misguided to think that: (1) Old data of an organization is irrelevant to current context or (2) data of another organization cannot be used for local solutions. Transfer learning is a promising research direction that transfers relevant cross data between time intervals and domains. [ABSTRACT FROM AUTHOR]

This paper presents the results of an empirical study aiming at comparing the support provided by ER and UML class diagrams during maintenance of data models. We performed one controlled experiment and two replications that focused on comprehension activities (the first activity in the maintenance process) and another controlled experiment on modification activities related to the implementation of given change requests. The results achieved were analyzed at a fine-grained level aiming at comparing the support given by each single building block of the two notations. Such an analysis is used to identify weaknesses (i.e., building blocks not easy to comprehend) in a notation and/or can justify the need of preferring ER or UML for data modeling. The analysis revealed that the UML class diagrams generally provided a better support for both comprehension and modification activities performed on data models as compared to ER diagrams. Nevertheless, the former has some weaknesses related to three building blocks, i.e., multi-value attribute, composite attribute, and weak entity. These findings suggest that an extension of UML class diagrams should be considered to overcome these weaknesses and improve the support provided by UML class diagrams during maintenance of data models. [ABSTRACT FROM AUTHOR]

Given the challenges of testing at the system level, only a fully automated approach can really scale up to industrial real-time embedded systems (RTES). Our goal is to provide a practical approach to the model-based testing of RTES by allowing system testers, who are often not familiar with the system's design but are application domain experts, to model the system environment in such a way as to enable its black-box test automation. Environment models can support the automation of three tasks: the code generation of an environment simulator to enable testing on the development platform or without involving actual hardware, the selection of test cases, and the evaluation of their expected results (oracles). From a practical standpoint-and such considerations are crucial for industrial adoption-environment modeling should be based on modeling standards (1) that are at an adequate level of abstraction, (2) that software engineers are familiar with, and (3) that are well supported by commercial or open source tools. In this paper, we propose a precise environment modeling methodology fitting these requirements and discuss how these models can be used to generate environment simulators. The environment models are expressed using UML/MARTE and OCL, which are international standards for real-time systems and constraint modeling. The presented techniques are evaluated on a set of three artificial problems and on two industrial RTES. [ABSTRACT FROM AUTHOR]

This paper is about understanding the nature of bug fixing by analyzing thousands of bug fix transactions of software repositories. It then places this learned knowledge in the context of automated program repair. We give extensive empirical results on the nature of human bug fixes at a large scale and a fine granularity with abstract syntax tree differencing. We set up mathematical reasoning on the search space of automated repair and the time to navigate through it. By applying our method on 14 repositories of Java software and 89,993 versioning transactions, we show that not all probabilistic repair models are equivalent. [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]

One of the more complex topics to teach to Software Engineering students is the conceptual modeling design, which has several concepts that students must learn in order to specify the structural, behavioral and interaction views of software systems. Learning the design of class diagrams is of paramount importance since these diagrams are used to guide concrete development tasks such as programming and testing, and, consequently, to avoid defective software products. Applying novel teaching/learning techniques in this topic may help students to reduce the defects that are committed at the moment of designing a class diagram. One interesting technique is the use of serious games, since they provide learning environments free of risks and pressure for students, allowing the students to know the topics that they must learn in a funny way. Serious games have been widely used in programming courses. We aim to investigate the feasibility to replicate this experience for conceptual modeling of class diagrams at Software Engineering courses. In this paper, we present a role-playing game especially focused on the class diagram, which is called Classutopia. This serious game provides modeling challenges, comprehension and correction of diagrams with different complexity levels for learning conceptual modeling design. [ABSTRACT FROM AUTHOR]

Developers might follow different file editing patterns when handling change requests. Existing research has warned the community about the potential negative impacts of some file editing patterns on software quality. However, very few studies have provided quantitative evidence to support these claims. In this paper, we propose four metrics to identify four file editing patterns: concurrent editing pattern, parallel editing pattern, extended editing pattern, and interrupted editing pattern. Our empirical study on three open source projects shows that 90% (i.e. 1935 out of 2140) of files exhibit at least one file editing pattern. More specifically (1) files that are edited concurrently by many developers are 1.8 times more likely to experience future bugs than files that are not concurrently edited; (2) files edited in parallel with too many other files by the same developer are 2.9 times more likely to exhibit future bugs than files individually edited; (3) files edited over an extended period of time are 1.9 times more likely to experience future bugs than other files; and (4) files edited with long interruptions have 2.0 times more future bugs than other files. We also observe that the likelihood of future bugs in files experiencing all the four file editing patterns is 3.9 times higher than in files that are never involved in any of the four patterns. We further investigate factors impacting the occurrence of these file editing patterns along three dimensions: the ownership of files, the type of change requests in which the files were involved, and the initial code quality of the files. Results show that a file with a major owner is 0.6 times less likely to exhibit the concurrent editing pattern than files without major owners. Files with bad code quality (e.g. highMcCabe's complexity, high coupling between objects, and lack of cohesion) are more likely to experience the four editing patterns. By ensuring a clear ownership and improving code quality, the negative impact of the four patterns could be reduced. Overall, our findings could be used by software development teams to warn developers about risky file editing patterns. [ABSTRACT FROM AUTHOR]

In this paper, we describe research results arising from a technology transfer exercise on agent-oriented requirements engineering with an industry partner. We introduce two improvements to the state-of-the-art in agent-oriented requirements engineering, designed to mitigate two problems experienced by ourselves and our industry partner: (1) the lack of systematic methods for agent-oriented requirements elicitation and modelling; and (2) the lack of prescribed deliverables in agent-oriented requirements engineering. We discuss the application of our new approach to an aircraft turnaround simulator built in conjunction with our industry partner, and show how agent-oriented models can be derived and used to construct a complete requirements package. We evaluate this by having three independent people design and implement prototypes of the aircraft turnaround simulator, and comparing the three prototypes. Our evaluation indicates that our approach is effective at delivering correct, complete, and consistent requirements that satisfy the stakeholders, and can be used in a repeatable manner to produce designs and implementations. We discuss lessons learnt from applying this approach. [ABSTRACT FROM PUBLISHER]