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]

The health of mobile software ecosystems is closely related to the interests of software developers, end‐users, and stakeholders. Therefore, it is crucial to maintain the mobile software ecosystem healthy and functioning. Researchers have done considerable research on mobile software ecosystems like Android and iOS. However, the evolution laws implicit in mobile software ecosystems have not attracted widespread attention. This paper proposes a research framework for investigating the evolution process and influencing factors of mobile software ecosystems based on community mining. Firstly, we mine the evolving ecosystem from many mobile software projects based on a community detection algorithm. Then we analyze the evolution process of the ecosystem by identifying evolution events in different periods. Furthermore, we utilize the multinomial logistics regression model to analyze the relevant indicators and summarize the crucial factors affecting the evolution. Meanwhile, by training the long short term memory (LSTM) model to predict evolution events, our prediction accuracy can reach 75%. This work can be used to maintain and improve the healthy operations of mobile software ecosystems. [ABSTRACT FROM AUTHOR]

Similar to software systems, programming languages evolve substantially over time. Indeed, the community has more recently seen the release of new versions of mainstream languages in shorter and shorter time frames. For instance, the C++ working group has begun to release a new version of the language every 3 years, which now has a greater number of modern C++ features and improvements in modern standards (C++11, C++14, C++17, and C++ 20). Nonetheless, there is little empirical evidence on how developers are transitioning to use modern C++ constructs in legacy systems, and not understanding the trends and reasons for adopting these new modern C++ features might hinder software developers in conducting rejuvenation efforts. In this paper, we conduct an in‐depth study to understand the development practices of KDE contributors to evolve their projects toward the use of modern C++ features. Our results show a trend in the widespread adoption of some modern C++ features (lambda expressions, auto‐typed variables, and range‐based for) in KDE community projects. We also found that developers in the KDE community are making large efforts to modernize their programs using automated tools, and we present some modernization scenarios and the benefits of adopting modern C++ features of the C++ programming language. Our results might help C++ software developers, in general, to evolve C++ legacy systems and tools builders to implement more effective tools that could help in rejuvenation efforts. [ABSTRACT FROM AUTHOR]

Recent research works have proven that duplicate bug reports can provide helpful information to assist developers in software tasks such as fault localization and program fixing, while thoroughly reading duplicate bug reports is time‐consuming and inefficient. Summarization is a possible solution for gaining essential information quickly. However, there are many challenges when applying existing summarizing techniques on duplicate bug reports. Duplicate bug reports describe the same problem from different views and vary in quality, content, and writing style. Moreover, the code snippet understanding and the semantic gap between natural and programming languages make the summary generation even more difficult. Thus, in this paper, we want to investigate whether the state‐of‐the‐art summarization approaches can overcome the resistance and generate an effective summary for duplicate bug reports. We collected more than 8,000 groups of duplicate reports from GitHub and labeled 60 groups with 149 reports manually for the evaluation. Results showed that although the existing summarization approaches can work on duplicate bug reports, there are significant differences between them when it comes to code snippet summarization. Moreover, several methods can be very sluggish for summarizing long bug reports. Our study provides insights and guidelines for choosing proper summarization approaches in different scenarios. [ABSTRACT FROM AUTHOR]

Industrial facilities collect large volumes of data, store them according to prescribed protocols, and then interpret them for process decision‐making. Several sources and types of error contaminate these data for various reasons, but especially because they come from unreliable or unpredictable instruments. Data (or signal) processing corrects measurement errors to improve fidelity. Here, we highlight decision‐making applications and signal processing methods. To fully appreciate the state‐of‐the‐art, we interviewed plant data experts and software developers in the pulp and paper industry to examine how they apply signal processing methods in the context of decision‐making, including the value of process data, how these data are used, and the major barriers that prevent plants from using data. Process experts clean data thoroughly with basic approaches compared to the advanced techniques available in the recent literature. The interviews demonstrate that decisions in industry are primarily based on steady‐state process operating data. Challenges and barriers that prevent the use of process data to their full potential relate to resource limitations (people, time, and money), an entrenched culture, and access to recent technology. In practice, experts consider, implicitly or explicitly, data that represent the process operating under steady‐state conditions. A plant model that represents steady‐state operations is easier to interpret, is presented in a form that is usable by plant operators, and in this way, better enables decision‐making. [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]

Workflow temporal verification is conducted to guarantee on-time completion, which is one of the most important QoS (Quality of Service) dimensions for business processes running in the cloud. However, as today's business systems often need to handle a large number of concurrent customer requests, conventional response-time based process monitoring strategies conducted in a one-by-one fashion cannot be applied efficiently to a large batch of parallel processes because of significant time overhead. Similar situations may also exist in software companies where multiple software projects are carried out at the same time by software developers. To address such a problem, based on a novel runtime throughput consistency model, this paper proposes a QoS-aware throughput based checkpoint selection strategy, which can dynamically select a small number of checkpoints along the system timeline to facilitate the temporal verification of throughput constraints and achieve the target on-time completion rate. Experimental results demonstrate that our strategy can achieve the best efficiency and effectiveness compared with the state-of-the-art as and other representative response-time based checkpoint selection strategies. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

As the number of infrastructure-as-a-service (IaaS) cloud offers in the market increases, selecting an appropriate configuration of cloud resources for a given application becomes a non-trivial task even for experienced developers. Because cloud resources are relatively cheap, usually charged by the hour, developers could systematically evaluate the performance of their application using different resource types from different cloud providers, thus allowing them to accurately identify the best providers and resource types for their application. However, conducting systematic performance tests in multiple IaaS clouds may require a significant amount of planning and configuration effort from application developers. This paper presents Cloud Crawler, a declarative environment for specifying and conducting application performance tests in IaaS clouds. The environment includes a novel declarative domain-specific language, Crawl, by means of which cloud users can describe, at a high abstraction level, a large variety of performance evaluation scenarios for a given application, and a scenario execution engine, Crawler, which automatically configures, executes, and collects the results of the scenarios described in Crawl. The paper also reports on how Cloud Crawler has been successfully used to systematically test the performance of two open-source web applications in public IaaS clouds. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

In this paper, we aim to provide prototype validation in both custom and packaged software development with a theoretical framework located within the philosophy of science. Towards that end, we consider Popperian and Quinean accounts of scientific knowledge and argue that the theoretical underpinning of prototype validation is Quine’s holistic philosophy of science, whose cornerstone principle is that all beliefs are revisable. Specifically, our thesis is that the systems developer and software consumer (user or customer) join forces – not as Popperian falsifiers, who make a decision rule to reject the prototype on account of any divergence, major or minor, from the software consumer’s mental model, but – as Quinean revisers, with the objective of fine-tuning the prototype (or the software consumer’s mental model) so that the prototype and the software consumer’s mental model are congruent with each other. This paper suggests that prototype revisions are belief revisions, and, as such, should be guided – and are guided – by pragmatic norms, such as conservatism, simplicity and generality, and are influenced by social, or sociological, factors as well. Finally, we discuss the relevance, value and pragmatic implications of a Quinean philosophy of science framework for research and practice. [ABSTRACT FROM AUTHOR]

Camera trapping has revolutionized wildlife ecology and conservation by providing automated data acquisition, leading to the accumulation of massive amounts of camera trap data worldwide. Although management and processing of camera trap‐derived Big Data are becoming increasingly solvable with the help of scalable cyber‐infrastructures, harmonization and exchange of the data remain limited, hindering its full potential. There is currently no widely accepted standard for exchanging camera trap data. The only existing proposal, "Camera Trap Metadata Standard" (CTMS), has several technical shortcomings and limited adoption. We present a new data exchange format, the Camera Trap Data Package (Camtrap DP), designed to allow users to easily exchange, harmonize and archive camera trap data at local to global scales. Camtrap DP structures camera trap data in a simple yet flexible data model consisting of three tables (Deployments, Media and Observations) that supports a wide range of camera deployment designs, classification techniques (e.g., human and AI, media‐based and event‐based) and analytical use cases, from compiling species occurrence data through distribution, occupancy and activity modeling to density estimation. The format further achieves interoperability by building upon existing standards, Frictionless Data Package in particular, which is supported by a suite of open software tools to read and validate data. Camtrap DP is the consensus of a long, in‐depth, consultation and outreach process with standard and software developers, the main existing camera trap data management platforms, major players in the field of camera trapping and the Global Biodiversity Information Facility (GBIF). Under the umbrella of the Biodiversity Information Standards (TDWG), Camtrap DP has been developed openly, collaboratively and with version control from the start. We encourage camera trapping users and developers to join the discussion and contribute to the further development and adoption of this standard. [ABSTRACT FROM AUTHOR]

SUMMARY Software maintenance accounts for the largest part of the costs of any program. During maintenance activities, developers implement changes (sometimes simultaneously) on artifacts in order to fix bugs and to implement new requirements. To reduce this part of the costs, previous work proposed approaches to identify the artifacts of programs that change together. These approaches analyze historical data, mined from version control systems, and report change patterns, which lead at the causes, consequences, and actors of the changes to source code files. They also introduce so-called change patterns that describe some typical change dependencies among files. In this paper, we introduce two novel change patterns: the asynchrony change pattern, corresponding to macro co-changes (MC), that is, of files that co-change within a large time interval (change periods) and the dephase change pattern, corresponding to dephase macro co-changes (DC), that is, MC that always happens with the same shifts in time. We present our approach, that we named Macocha, to identify these two change patterns in large programs. We use the k-nearest neighbor algorithm to group changes into change periods. We also use the Hamming distance to detect approximate occurrences of MC and DC. We apply Macocha and compare its performance in terms of precision and recall with UMLDiff (file stability) and association rules (co-changing files) on seven systems: ArgoUML, FreeBSD, JFreeChart, Openser, SIP, XalanC, and XercesC developed with three different languages (C, C++, and Java). These systems have a size ranging from 532 to 1693 files, and during the study period, they have undergone 1555 to 23,944 change commits. We use external information and static analysis to validate (approximate) MC and DC found by Macocha. Through our case study, we show the existence and usefulness of these novel change patterns to ease software maintenance and, potentially, reduce related costs. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Summary: Software product lines enable developers to derive similar products from a common code base. Existing implementation techniques can be categorized as composition‐based and annotation‐based approaches, with both approaches promising complementary benefits. However, annotation‐based approaches are commonly used in practice despite composition allowing physical separation of features and, thus, improving traceability and maintenance. A main hindrance to migrate annotated systems toward a composition‐based product line is the challenging and time‐consuming transformation task. For a company, it is difficult to predict the corresponding costs, and a successful outcome is uncertain. To overcome such problems, a solution proposed by the previous work is to use a hybrid approach, utilizing composition and annotation simultaneously. Based on this idea, we introduce a stepwise migration process from annotation‐based toward composition‐based approaches to lower the adoption barrier of composition. This process itself is independent of used implementation techniques and enables developers to incrementally migrate toward composition. We support our approach with detailed examples by partially migrating a real‐world system. In detail, we describe the following: (1) our migration process, (2) its application on a real‐world system, and (3) discuss practical challenges we face. We implemented the proposed approach and show that appropriate tool support helps to migrate toward composition‐based product lines. Based on the case study, we show that the hybrid product lines work correctly and can compete with the performance of the original annotated system. However, the results also illustrate open issues that have to be solved to apply such migrations in practice. [ABSTRACT FROM AUTHOR]

SUMMARY Although the idea of context-awareness was introduced almost two decades ago, few mobile software applications are available today that can sense and adapt to their run-time environment. The development of context-aware and self-adaptive applications is complex and few developers have experience in this area. On the basis of several demonstrators built by the joint European research project MUSIC, this paper describes typical context and adaptation features relevant for the development of context-aware and self-adaptive mobile applications. We explain how the demonstrators were realised using the open-source platform MUSIC and present the feedback of the developers of these demonstrators. The main contribution of this paper is to show how the development complexity of context-aware and self-adaptive mobile applications can be mastered by using an adaptation framework such as MUSIC. Copyright © 2012 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

SUMMARY H.264/MPEG-4 part 10 is the latest standard for video compression and promises a significant advance in terms of quality and distortion compared with the commercial standards currently most in use such as MPEG-2 or MPEG-4. To achieve this better performance, H.264 adopts a large number of new/improved compression techniques compared with previous standards, albeit at the expense of higher computational complexity. In addition, in recent years new hardware accelerators have emerged, such as graphics processing units (GPUs), which provide a new opportunity to reduce complexity for a large variety of algorithms. However, current GPUs suffer from higher power consumption requirements because of its design. Up to now, GPU-based software developers have not taken this into account. In this paper, we present a detailed procedure to implement the H.264 motion estimation for a GPU, with the aim of reducing time and, as a consequence, the energy consumption. The results show a negligible drop in rate distortion with a time reduction of over 91.5% on average and it reduces the energy consumption by a factor of 11.78 compared with the reference implementation. Copyright © 2011 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

The article discusses a study which investigated a mature Scrum team in a large organization and their interactions with the User Experience (UX) designers working on the same project. Particular focus is given to the difference between agile development and UX design methods for software development. Results of the study showed that ongoing articulation work by developers have led to cooperation between Agile developers and UX designers. Findings also revealed the themes which centre around the types of activities allowing the transformation of paper-based UX designs into working software.

When a set of people are connected by a set of meaningful social relationships we talk of a social network. A social network represents a social structure and the underlying structural patterns can be used to analyze and comprehend how people relate to each other and their emergent behavior as a group. Developing software is fundamentally a human activity. Developers cooperate and exchange knowledge and information, creating in fact, a particular type of social network that we call knowledge network. In this paper we investigate knowledge networks in software development teams by applying social network analysis and we use the Apache web server as a case study. By analyzing the structural communication and coordination patterns in Apache we have been able to identify the Apache knowledge network, highlight potential communication bottlenecks, and find brokers and important coordination points in the software development team. Furthermore, our work enables a software architect to analyze and maintain the organization and the software architecture aligned during software evolution. An important lesson that we have is that the analysis of knowledge networks constitutes an additional tool to be added to the traditional software architecture assessment methods. Copyright © 2009 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Problem frames and assurance cases are two current research areas that can improve – and have improved – system dependability, in critical and noncritical systems alike. While these two techniques are effective separately, their synthesis is much more powerful. This paper describes the synthesis of these two techniques and the rationale behind the synthesis, the particular pieces that influence each other, and the beginning of a process to integrate the two in software system development. A detailed example of the application of the synthesis is also provided. [ABSTRACT FROM AUTHOR]

Component-based development has emerged as a system engineering approach that promises rapid software development with fewer resources. Yet, improved reuse and reduced cost benefits from software components can only be achieved in practice if the components provide reliable services, thereby rendering component analysis and testing a key activity. This paper discusses various issues that can arise in component testing by the component user at the stage of its integration within the target system. The crucial problem is the lack of information for analysis and testing of externally developed components. Several testing techniques for component integration have recently been proposed. These techniques are surveyed here and classified according to a proposed set of relevant attributes. The paper thus provides a comprehensive overview which can be useful as introductory reading for newcomers in this research field, as well as to stimulate further investigation. Copyright © 2006 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Opportunistic reuse is a need based sourcing of software modules without a prior reuse plan. It is a common tactical approach in software development. Developers often reuse an external software module opportunistically to improve their productivity. But, studies have shown that this results in extensive refactoring and adds maintenance owes. We assert this problem to the mismatches between the software under development and the reused external module; caused because of their different assumptions and constraints. We highlight the problems of such opportunistic reuse practices with the help of a case study. In our study, we found issues such as unanticipated behavior, violated constraints, conflict in assumption, fragile structure, and software bloat. In this paper, we like to draw attention of the research community to the wide spread opportunistic reuse practices and the lack of methods to pro-actively identify and resolve the mismatches. We propose the need for supporting developers in reasoning before reuse from the perspective of identifying and fixing both local and global mismatches. Furthermore, we identify other opportunistic software development practices where similar issues can be observed and also suggest the research areas where further investigation can benefit developers in improving their productivity. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

The life cycle of a large-scale software system can undergo many releases. Each release often involves hundreds or thousands of revisions committed by many developers over time. Many code changes are made in a systematic and collaborative way. However, such systematic and collaborative code changes are often undocumented and hidden in the evolution history of a software system. It is desirable to recover commonalities and associations among dispersed code changes in the evolutionary trajectory of a software system. In this paper, we present Summarizing Evolutionary Trajectory by Grouping and Aggregation (SETGA), an approach to summarizing historical commit records as trajectory patterns by grouping and aggregating relevant code changes committed over time. The SETGA extracts change operations from a series of commit records from version control systems. It then groups extracted change operations by their common properties from different dimensions such as change operation types, developers, and change locations. After that, SETGA aggregates relevant change operation groups by mining various associations among them. We implement SETGA and conduct an empirical study with 3 open-source systems. We investigate underlying evolution rules and problems that can be revealed by the identified patterns and analyze the evolution of trajectory patterns in different periods. The results show that SETGA can identify various types of trajectory patterns that are useful for software evolution management and quality assurance. [ABSTRACT FROM AUTHOR]

ABSTRACT Information workers and software developers are exposed to work fragmentation, an interleaving of activities and interruptions during their normal work day. Small-scale observational studies have shown that this can be detrimental to their work. In this paper, we perform a large-scale study of this phenomenon for the particular case of software developers performing software evolution tasks. Our study is based on several thousands interaction traces collected by Mylyn and the Eclipse Usage Data Collector. We observe that work fragmentation is correlated to lower observed productivity at both the macro level (for entire sessions) and at the micro level (around markers of work fragmentation); further, longer activity switches seem to strengthen the effect, and different activities seem to be affected differently. These observations give ground for subsequent studies investigating the phenomenon of work fragmentation. [ABSTRACT FROM AUTHOR]

Software process improvement (SPI) has become one of the main strategies employed by small software enterprises to reduce their development costs or to increase the quality of their products and their development speed. Recent studies show that many small organizations still struggle to implement SPI initiatives successfully. One of the main problems with small organizations is that they usually lack the knowledge and practical experience about the human, social, and organizational phenomena associated with SPI initiatives and their effects. The objective of this paper is to present a grounded action research study that investigated SPI initiatives conducted by 10 Mexican small enterprises. The main product of this study is an initial theoretical framework that attempts to explain the effects of SPI initiatives in small organizations. We concluded that SPI initiatives affect organizational elements (i.e., structure, culture, organizational climate, projects) and human resources (i.e., employees and managers), and vice versa, and these elements are highly interrelated. Therefore, small enterprises need comprehensive SPI strategies that consider, in an integrated way, changes in processes, organizational elements, and human resources. SPI practitioners can use the results of this study to define more efficient and effective strategies to implement SPI initiatives in small organizations. Copyright © 2016 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

High-maturity software development processes, such as the Team Software Process and the accompanying Personal Software Process (PSP), can generate significant amounts of data that can be periodically analyzed to identify performance problems, determine their root causes, and devise improvement actions. However, there is a lack of tool support for automating that type of analysis, and hence diminish the manual effort and expert knowledge required. So, we propose in this paper a comprehensive performance model, addressing time estimation accuracy, quality, and productivity, to enable the automated (tool based) analysis of performance data produced by PSP developers, namely, identify and rank performance problems and their root causes. A PSP data set referring to more than 30 000 projects was used to validate and calibrate the model. Copyright © 2015 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Project management is widely studied and has several tools that aid in the efficiency and effectiveness of software production. However, in project management, numerous risk factors are involved in the development of software. These risk factors interact in a dynamic and non-linear way, hindering decisionmaking. The objective of this paper is to present a model of systems dynamics, which is a descriptive technique used for modeling and simulating systems, involving risk factors that strongly influence the development of software. The model generated is a tool that aims to assist project managers in their decision-making. The relationships between variables were extracted from actual or empirical experiments available in the literature, thus bringing the model results closer to the real world. The model enables reproducing scenarios in which real-world tests would be costly or dangerous to be carried out, allowing the impacts of risks in software development process to be analyzed. Copyright © 2015 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Introduction: Translating narrative clinical guidelines to computable knowledge is a long‐standing challenge that has seen a diverse range of approaches. The UK National Institute for Health and Care Excellence (NICE) Content Advisory Board (CAB) aims ultimately to (1) guide clinical decision support and other software developers to increase traceability, fidelity and consistency in supporting clinical use of NICE recommendations, (2) guide local practice audit and intervention to reduce unwarranted variation, (3) provide feedback to NICE on how future recommendations should be developed. Objectives: The first phase of work was to explore a range of technical approaches to transition NICE toward the production of natively digital content. Methods: Following an initial 'collaborathon' in November 2022, the NICE Computable Implementation Guidance project (NCIG) was established. We held a series of workstream calls approximately fortnightly, focusing on (1) user stories and trigger events, (2) information model and definitions, (3) horizon‐scanning and output format. A second collaborathon was held in March 2023 to consolidate progress across the workstreams and agree residual actions to complete. Results: While we initially focussed on technical implementation standards, we decided that an intermediate logical model was a more achievable first step in the journey from narrative to fully computable representation. NCIG adopted the WHO Digital Adaptation Kit (DAK) as a technology‐agnostic method to model user scenarios, personae, processes and workflow, core data elements and decision‐support logic. Further work will address indicators, such as prescribing compliance, and implementation in document templates for primary care patient record systems. Conclusions: The project has shown that the WHO DAK, with some modification, is a promising approach to build technology‐neutral logical specifications of NICE recommendations. Implementation of concurrent computable modelling by multidisciplinary teams during guideline development poses methodological and cultural questions that are complex but tractable given suitable will and leadership. [ABSTRACT FROM AUTHOR]

SUMMARY One of the key benefits of using intrusion-tolerant systems is the possibility of ensuring correct behavior in the presence of attacks and intrusions. These security gains are directly dependent on the components exhibiting failure diversity. To what extent failure diversity is observed in practical deployment depends on how diverse are the components that constitute the system. In this paper, we present a study with operating system's (OS's) vulnerability data from the NIST National Vulnerability Database (NVD). We have analyzed the vulnerabilities of 11 different OSs over a period of 18 years, to check how many of these vulnerabilities occur in more than one OS. We found this number to be low for several combinations of OSs. Hence, although there are a few caveats on the use of NVD data to support definitive conclusions, our analysis shows that by selecting appropriate OSs, one can preclude (or reduce substantially) common vulnerabilities from occurring in the replicas of the intrusion-tolerant system. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

SUMMARY Developers often have to locate the parts of source code that contribute to a specific feature during software maintenance tasks. This activity, referred to as feature location in software engineering, is a human-intensive and knowledge-intensive process. Researchers have investigated (semi-)automatic analysis-based techniques to assist developers in such feature location activities. However, little work has been carried out on better understanding how developers perform feature location tasks. In this paper, we report an exploratory study of feature location process, consisting of three experiments in which developers were given unfamiliar systems and asked to complete six feature location tasks. Our study suggests that feature location process can be understood hierarchically at three levels of granularity: phase, pattern, and action. Furthermore, our statistical analysis shows that these feature location phases, patterns, and actions can be effectively imparted to junior developers and consequently improve their performance on feature location tasks. Our qualitative observations and interviews also suggest that external factors, for example, human factors, task properties, and in-process feedbacks, affect the choices and usage of different feature location patterns and actions. Our results open up new opportunities to feature location research, which could lead to better tool support and more rigorous feature location process. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

SUMMARY Test-suite augmentation techniques enhance test suites for software changes. In previous work, we introduced an augmentation technique that enumerates the conditions for the propagation of the effects of changes. Empirical studies showed that this technique can test changes effectively but, because of the high complexity of the technique, the experiments were small and the propagation distances from each change were limited. In this paper, we present a new, demand-driven approach for performing this propagation-based testing of changes that achieves much greater distances and that enables larger and more significant studies. We implemented this new approach and studied it on a set of changes in Java programs by comparing, to a larger extent than possible before, propagation-based strategies with other change testing techniques. Our results confirm, with statistical significance, the superiority of propagation-based strategies over other techniques, and show that these strategies are especially effective for those changes that are the most difficult to test.Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

SUMMARY Traditional industrial practice often involves the ad hoc reuse of source code that was not designed for that reuse. Such pragmatic reuse tasks play an important role in disciplined software development. Pragmatic reuse has been seen as problematic due to a lack of systematic support, and an inability to validate that the reused code continues to operate correctly within the target system. Although recent work has successfully systematized support for pragmatic reuse tasks, the issue of validation remains unaddressed. In this paper, we present a novel approach and tool to semi-automatically reuse and transform relevant portions of the test suite associated with pragmatically reused code, as a means to validate that the relevant constraints from the originating system continue to hold, while minimizing the burden on the developer. We conduct a formal experiment with experienced developers, to compare the application of our approach versus the use of a standard IDE (the 'manual approach'). We find that, relative to the manual approach, our approach: reduces task completion time; improves instruction coverage by the reused test cases; and improves the correctness of the reused test cases. Copyright © 2012 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

One of the dominant characteristics of contemporary software development is the global distribution of tasks, of developers, of information and of technologies. Undoubtedly, such distribution engenders new coordination challenges in the form of distance-related interdependencies. One of the predominant processes of addressing these challenges is electronic meetings (or teleconferences). However, the functions of these meetings for coordination purposes are not yet understood. The distinctive conventions of teleconferences and their causal relationships that lead to optimal coordination of global software development (GSD) projects are also not yet understood. In this paper, the functions of teleconferences held by globally distributed software developers to coordinate their work in the face of global distribution of resources, cross-site information interdependencies and continuously changing software requirements are analysed. The analysis is based on a qualitative study of how a subunit of 13 software developers, distributed across three sites in the USA and one in Republic of Ireland, used teleconferences to address its coordination challenges. The paper proffers a teleconference approach to GSD coordination by arguing that the functions of teleconferences manifest in software developers' multitasking; their ready access to all their information as additional benefits; flexibility in their communicative behaviours; and a reduction in their structure overload. This approach draws attention to these manifestations as distinctive conventions of the de-structured meeting, which de-structuring is occasioned by organic information processing needs in teleconferencing. This approach also explains why the combination of global distribution and teleconferences is a strategic opportunity for information processing for software process coordination. [ABSTRACT FROM AUTHOR]

Software process improvement (SPI) can be seen as a profession, having its own competence needs and its own community of interest. European projects EQN and EU Cert have defined skills sets and a common certification scheme for about 20 professions, mainly in IT domain. A common way to describe IT domain from process perspective is concept ‘3S’ (software, systems, services). Software process can be seen as the first spearhead among these. First software process models, such as Capability Maturity Model (CMM) and SPICE, have existed already about 20 years. That is also the main reason to start process improvement profession from software processes, because we have much experience in that. Software Process Improvement Manager (SPI Manager) is one of new topics in EU Cert project. Development of SPI Manager training and certification scheme has been done in many small steps so far. This paper explains the current structure and main components of SPI Manager competences, training needs and certification scheme. Several other schemes will be developed in future for PI-related competences. Current version of SPI Manager skills set is based mainly on software, systems and service processes and their related reference models. It could be used in future also in other domains than IT. Copyright © 2009 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

The promise of future many-core processors, with hundreds of threads running concurrently, has led the developers of linear algebra libraries to rethink their design in order to extract more parallelism, further exploit data locality, attain better load balance, and pay careful attention to the critical path of computation. In this paper we describe how existing serial libraries such as (C)LAPACK and FLAME can be easily parallelized using the SMPSs tools, consisting of a few OpenMP-like pragmas and a run-time system. In the LAPACK case, this usually requires the development of blocked algorithms for simple BLAS-level operations, which expose concurrency at a finer grain. For better performance, our experimental results indicate that column-major order, as employed by this library, needs to be abandoned in benefit of a block data layout. This will require a deeper rewrite of LAPACK or, alternatively, a dynamic conversion of the storage pattern at run-time. The parallelization of FLAME routines using SMPSs is simpler as this library includes blocked algorithms (or algorithms-by-blocks in the FLAME argot) for most operations and storage-by-blocks (or block data layout) is already in place. Copyright © 2009 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

In the companion article, Spirit of the Game: Empowering Students as Designers in Schools?, author Cher Ping Lim puts forth strong arguments supporting the creation and use of curricular, educational games in our schools and education. His essay ends with the question ‘Can students build such games?’ This paper responses to this question and provides examples of how students can design and build games within the school curriculum to enhance engagement in the classrooms. Two approaches are suggested: Mini-game-based curriculum and complex game for entire course. [ABSTRACT FROM AUTHOR]

A peer-review process for assessing the contribution of artifacts, such as games and software to research, is proposed. Games and software produced as research output by academics tend to be accredited within their institution through discussion of the artifact, rather than directly. An independent judg-ment by peers confirming an artifact's contribution of something new, concep-tually or practically, to a discipline can then be used by academics as evidence in secondary research appraisals, such as promotion appraisals or research assessment exercises, an example being the United Kingdom's Research Assessment Exercise. © Wiley Periodicals, Inc. [ABSTRACT FROM AUTHOR]

Problem frames are an approach to requirements modelling that is gaining increasing attention and popularity, as it addresses the essential activity of understanding and describing the problem to be solved before undertaking the actual development phases. This paper reports a study concerning the possibility of enhancing the problem frames methodology with concepts derived from requirements modelling techniques based on scenarios and histories. The goal of this research is to make problem frames even more appealing to software developers, who are generally familiar with the ideas underlying scenario-based modelling. The results presented here are encouraging: a well-known problem, often used to illustrate problem frames (the sluice gate control), was studied with the help of scenarios, modelled by means of histories. Scenarios were also employed to support the merging of subproblems, for addressing the frame concern issues and for supporting design models. In all these activities the proposed approach proved helpful. [ABSTRACT FROM AUTHOR]

Abstract. Although user participation in systems development is widely believed to have positive impacts on user acceptance, it does not guarantee success and there is still much that we do not know about how and why user participation sometimes delivers positive benefits, but not always. Much of the prior research on user participation assumes that user–developer communication will ensure that the resulting system will be designed to meet users’ needs and will be accepted by them. The nature and quality of the communication between users and developers, however, remains an understudied aspect of user participation. In this paper, we focus on the user–developer communication process. We propose a process model that delineates four stages of communication between users and software developers, and we argue that these stages must occur for user participation to lead to effective outcomes. To illustrate our model, we apply it to analyse a ‘critical case study’ of a software project that failed despite high levels of user involvement. We show that when ‘communication lapses’ occurred in several of the user–developer communication stages, developers failed to be informed regarding the underlying reasons that users avoided the system. Based on the insights from this case study, we advise researchers and practitioners how to leverage the potential benefits of user participation, rather than take them for granted. [ABSTRACT FROM AUTHOR]

Summary: HTML is being massively used as an interface to provide services to users. Web developers are producing and changing sites at a high pace while trying to support the latest HTML standards. In this context, it is common to find websites that do not comply with the standards and fail to be correctly processed by browsers. Considering this dynamic environment and the increasingly large diversity of browsers with frequent updates, the appearance of problems in web pages is a common, sometimes severe, and hard‐to‐track problem. In this short communication, we describe the initial design of an approach that will be used to obtain information regarding the characteristics of HTML documents on the Web and extract indicators of representative errors made by their developers. Preliminary results show nearly 90% of the pages analyzed having at least one type of error and the prevalence of a small number of error types. [ABSTRACT FROM AUTHOR]

Parallel programs are intrinsically non-deterministic, and therefore the techniques of cyclical debugging that are commonly used for sequential programs ire not suitable for parallel ones. This paper proposes a method to reproduce Occam program behaviour. Saving information on the timer values input by the program and the guards selected at run-time on alternative commands allows program replay, i.e. it makes it possible to re-execute the program deterministically with the same inputs following the same instruction path. This enables the software developer to use tools such as debuggers and intrusive monitors to help identify program faults. After discussing possible implementations of the proposed technique, IRD (an interactive replay debugger for Occam programs) is described. Finally, the use of the IRD in a sample debug session is presented as an example. [ABSTRACT FROM AUTHOR]

Maintainers of old code often need to discover where particular program features are implemented. This paper presents a method, called `software reconnaissance' for answering this question through an analysis of the execution of different test cases. The method is quite easy to implement, requiring only a test coverage monitor, some simple tools, and a surprisingly small number of test cases. A statistical case study is presented that shows the kind of results that can be obtained on a typical medium-sized program. The method seems to be effective in identifying a small number of code components that are unique to a particular program feature, though it may not find all components that make up the feature's delocalized plan. A small protocol case study shows that professional programmers can learn to use the method quickly and can use the information that it produces. Software reconnaissance may be a simple but useful addition to the maintainer's tool kit in that it provides starting points for understanding a large program and a way of recovering some requirements traceability information from old code. For the researcher, it also provides a novel functionality `view' of software that maps features to program components at different levels of precision. [ABSTRACT FROM AUTHOR]

SUMMARY Our knowledge of how to solve software engineering problems is increasingly being encapsulated in tools. These tools are at their strongest when they operate in a pre-existing integrated development environment (IDE). This approach allows integration with existing elements such as compilers, debuggers, profilers, visualizers, and numerous other development and, often, runtime tools. Tools and environments to increase software quality and productivity have always been an important aspect of software engineering. A plug-in is a modern way for incrementally adding new tools into existing environments. However, building tools as plug-ins can be challenging. How do they interact with the core environment? How do they interact with one another - especially since each developer may choose a different set of plug-ins? How can we share tools across different, and future, core development environments? [ABSTRACT FROM AUTHOR]

SUMMARY Software dependences play a vital role in programme comprehension, change impact analysis and other software maintenance activities. Traditionally, these activities are supported by source code analysis; however, the source code is sometimes inaccessible or difficult to analyse, as in hybrid systems composed of source code in multiple languages using various paradigms (e.g. object-oriented programming and relational databases). Moreover, not all stakeholders have adequate knowledge to perform such analyses. For example, non-technical domain experts and consultants raise most maintenance requests; however, they cannot predict the cost and impact of the requested changes without the support of the developers. We propose a novel approach to predicting software dependences by exploiting the coupling present in domain-level information. Our approach is independent of the software implementation; hence, it can be used to approximate architectural dependences without access to the source code or the database. As such, it can be applied to hybrid systems with heterogeneous source code or legacy systems with missing source code. In addition, this approach is based solely on information visible and understandable to domain users; therefore, it can be efficiently used by domain experts without the support of software developers. We evaluate our approach with a case study on a large-scale enterprise system, in which we demonstrate how up to 65% of the source code dependences and 77% of the database dependences are predicted solely based on domain information. Copyright © 2013 John Wiley & Sons, Ltd. [ABSTRACT FROM AUTHOR]

Open Source (OS) is a phenomenon of increasing significance for organizations, offering the prospect of effective alternative business solutions and new business opportunities. A number of surveys have been conducted in various countries with the purpose of understanding the state of practice with respect to OS in companies. In this paper we report on a study of the perceptions of OS and the uptake of OS products and development models in Swedish companies. The study used purposeful sampling of companies that have an expressed interest in OS, and the survey was conducted using a set of pre-prepared questions. Its goal was to investigate the extent to which OS has influenced business thinking, as seen from the standpoint of stakeholders. We found that uptake is much higher than reported in earlier studies, but as with previous studies, activity is still concentrated in small and medium-sized enterprises (SMEs). There is increased evidence of interest beyond the simple use of OS components at the infrastructure level. Further, a significant proportion of the companies studied are supporting the OS community as well as benefiting from it. Support includes participation in existing projects and the release of new software under OS licenses. [ABSTRACT FROM AUTHOR]

Organizational downsizing research indicates that downsizing does not always realize its strategic intent and may, in fact, have a detrimental impact on organizational performance. In this paper, we extend the notion that downsizing negatively impacts performance and argue that organizational downsizing can potentially be detrimental to software quality performance. Using social cognitive theory (SCT), we primarily interpret the negative impacts of downsizing on software quality performance by arguing that downsizing results in a realignment of social networks (environmental factors), thereby affecting the self-efficacy and outcome expectations of a software professional (personal factors), which, in turn, affect software quality performance (outcome of behaviour undertaken). We synthesize relevant literature from the software quality, SCT and downsizing research streams and develop a conceptual model. Two major impacts of downsizing are hypothesized in the conceptual model. First, downsizing destroys formal and informal social networks in organizations, which, in turn, negatively impacts software developers' self-efficacy and outcome expectations through their antecedents, with consequent negative impacts on software development process efficiency and software product quality, the two major components of software quality performance. Second, downsizing negatively affects antecedents of software development process efficiency, namely top management leadership, management infrastructure sophistication, process management efficacy and stakeholder participation with consequent negative impacts on software quality performance. This theoretically grounded discourse can help demonstrate how organizational downsizing can potentially impact software quality performance through key intervening constructs. We also discuss how downsizing and other intervening constructs can be managed to mitigate the negative impacts of downsizing on software quality performance. [ABSTRACT FROM AUTHOR]

The article analyzes the problems facing Information Systems Development (ISD) and the practices applied by developers and managers. The authors give much emphasis on the concept of agility, and contrast the characteristics of Web development with agile development. They use contemporary literature on Web development as an example of research that argues a need for new concepts, methodologies, and tools as a result of fundamental changes in ISD. Information about solving information processing problems by means of executable code is discussed.

Abstract: Traditional software teams that implement agile methodologies frequently experience difficulty working efficiently as agile teams. While agile methodologies support and promote social activities and behaviors, the understanding of the social phenomena and challenges that arise during the transformation of traditional teams into agile teams is limited. We conducted an extensive 10‐month case study in a software enterprise to analyze the changes in the communication and social interactions of employees during the transformation process, and to delineate the social challenges that arise during this process. Using social interaction registers, we collected data on the communication and social interactions of employees, first when they worked as a traditional team and then as an agile team. Then, we processed the data using social network analysis methods to identify the differences between these 2 types of teams and to create graphs of communication and social interaction networks. We identified that the transformation process influences formal, informal, oral, and written communication and increases conjunctive and disjunctive social interactions. Further, from the results of interviews conducted with all the enterprise members, we identified 5 social challenges to transforming a traditional team into an agile one. The results of this research suggest that the transformation process requires broad changes in the relationships and interactions among employees. [ABSTRACT FROM AUTHOR]

Abstract: This article addresses the relationships between agile development and entrepreneurship. The objective of the study is to verify that the adoption of agile practices can promote entrepreneurial skills in software developers. In this study, agile practices were related to entrepreneurial skills, and developers of the software industry and academia professors were invited to contribute. Questionnaires were sent to the participants to obtain their opinion regarding this research. Participants also opined about the possibility of entrepreneurial skills being an observable behavior in agile culture, ie, if they are visible artifacts of agile culture. As a result, the study found a set of agile practices that promote entrepreneurial skills in software developers. That is, it was found that agile practices promote entrepreneurial behavior in these professionals. These entrepreneurial skills are sustained by the same basic values and assumptions that were learned by developers to resolve internal integration and external adaptation issues during the adoption of agile practices. In this article, an integration model has been adapted from other areas, thereby opening a new field of study involving the relationships between academic research and professional practice on entrepreneurship in the software area and agile development. [ABSTRACT FROM AUTHOR]

Summary: Recent rapid progress in machine learning (ML), particularly so‐called ‘deep learning’, has led to a resurgence in interest in explainability of artificial intelligence (AI) systems, reviving an area of research dating back to the 1970s. The aim of this article is to view current issues concerning ML‐based AI systems from the perspective of classical AI, showing that the fundamental problems are far from new, and arguing that elements of that earlier work offer routes to making progress towards explainable AI today. [ABSTRACT FROM AUTHOR]

Abstract: Empirical evidence regarding the connection between group development (maturity) and the success of software development teams is lacking. The purpose of this research is to gain a qualitative and quantitative understanding of how velocity and planning effectiveness of software teams connect to a group development model. The Group Development Questionnaire was given to 19 software developers from 4 work groups to assess their group development maturity. The work groups' responses to the survey were checked for correlation with development velocity and planning effectiveness. Semistructured interviews were conducted with 16 individuals from the same 4 work groups to explore issues about their group maturity and to validate the responses of the interviewees in the Group Development Questionnaire. The measurement of the fourth stage of group development had a strong association with the planning effectiveness measurement, which means that a team with less issues in the fourth phase of group development is more effective in adhering to its plans. On the other hand, group development and velocity showed no significant convergent validity. We conclude that the dynamics within software development teams might correlate to their ability to deliver the expected outcome as planned but not to their ability to develop tasks faster. [ABSTRACT FROM AUTHOR]

Abstract: An individual's decision‐making behavior is heavily influenced by and adapted to external environmental factors. Given that software development is a human‐centered activity, individual decision‐making behavior may affect the software project quality. Although environmental factors affecting decision‐making behavior in software projects have been identified in prior literature, there is not yet an objective and a full taxonomy of these factors. Thus, it is not trivial to manage these complex and diverse factors. To address this deficiency, we first design a semantic similarity algorithm between words by utilizing the synonymy and hypernymy relationships in WordNet. Further, we propose a method to measure semantic similarity between phrases and apply it into k‐means clustering algorithm to group these factors. Subsequently, we obtain a taxonomy of the environmental factors affecting individual decision‐making behavior in software projects, which includes 11 broad categories, each containing 2 to 5 sub‐categories. The taxonomy presented herein is obtained by an objective method, and quite comprehensive, with appropriate references provided. The taxonomy holds significant value for researchers and practitioners; it can help them to better understand the major aspects of environmental factors, also to predict and guide the behavior of individuals during decision making towards a successful completion of software projects. [ABSTRACT FROM AUTHOR]

Abstract: Transparent environments and social‐coding platforms as GitHub help developers to stay abreast of changes during the development and maintenance phase of a project. Especially, notification feeds can help developers to learn about relevant changes in other projects. Unfortunately, transparent environments can quickly overwhelm developers with too many notifications, such that they lose the important ones in a sea of noise. Complementing existing prioritization and filtering strategies based on binary compatibility and code ownership, we develop an anomaly detection mechanism to identify unusual commits in a repository, which stand out with respect to other changes in the same repository or by the same developer. Among others, we detect exceptionally large commits, commits at unusual times, and commits touching rarely changed file types given the characteristics of a particular repository or developer. We automatically flag unusual commits on GitHub through a browser plug‐in. In an interactive survey with 173 active GitHub users, rating commits in a project of their interest, we found that, although our unusual score is only a weak predictor of whether developers want to be notified about a commit, information about unusual characteristics of a commit changes how developers regard commits. Our anomaly detection mechanism is a building block for scaling transparent environments. [ABSTRACT FROM AUTHOR]