Comment-based concept location over system dependency graphs

Most of today's industries, from engineering to agriculture to health, are run on software. In such a context, ensuring software quality play an important role in most of current working environment and have a direct impact in any scientific and technical discipline. Software maintenance and testing have the crucial goal to find or discover possible software bugs (or defects) as early as possible, enabling software quality assurance. However, software maintenance and testing are very expensive and time-consuming activities for developers. For this reason, in the last years, several researchers in the field of Software Engineering (SE) devoted their effort in conceiving tools for boosting developers productivity during such development, maintenance and testing tasks. In this talk, I will first discuss some empirical work we performed to understand the main socio-technical challenges developers face when joining a new software project. I will discuss how to address them with the use of appropriate recommender systems aimed at supporting developers during program comprehension and maintenance tasks. Then, I'll show how Summarization Techniques are an ideal technology for supporting developers when performing testing and debugging activities. Finally, I will summarize the main research advances, the current open challenges/problems and possible future directions to exploit for boosting developers productivity.

Impact analysis (IA) is a critical software maintenance task that identifies the effects of a given set of code changes on a larger software project with the intention of avoiding potential adverse effects. IA is a cognitively challenging task that involves reasoning about the abstract relationships between various code constructs. Given its difficulty, researchers have worked to automate IA with approaches that primarily use coupling metrics as a measure of the “connectedness” of different parts of a software project. Many of these coupling metrics rely on static, dynamic, or evolutionary information and are based on heuristics that tend to be brittle, require expensive execution analysis, or large histories of co-changes to accurately estimate impact sets. In this paper, we introduce a novel IA approach, called Athena , that combines a software system’s dependence graph information with a conceptual coupling approach that uses advances in deep representation learning for code without the need for change histories and execution information. Previous IA benchmarks are small, containing less than ten software projects, and suffer from tangled commits, making it difficult to measure accurate results. Therefore, we constructed a large-scale IA benchmark, from 25 open-source software projects, that utilizes fine-grained commit information from bug fixes. On this new benchmark, our best performing approach configuration achieves an mRR, mAP, and HIT@10 score of 60.32%, 35.19%, and 81.48%, respectively. Through various ablations and qualitative analyses, we show that Athena ’s novel combination of program dependence graphs and conceptual coupling information leads it to outperform a simpler baseline by 10.34%, 9.55%, and 11.68% with statistical significance.

With the enhancement of hardware and software engineering, the effectiveness and correctness of software is less and less doubted and customers are more aware about whether software services are available or not when needed. Software maintenance is one of the main reasons that make software unavailable and it is often very expensive to perform maintenance tasks. Common approaches of studying software maintenance are to consider it as a static by‐product of software operation and only the maintenance cost is covered. In this paper, software maintenance policies are studied with the consideration of unavailable service time. A non‐homogeneous continuous Markov chain is adopted for modeling the software operation and maintenance process, and the cost of software unavailability that is brought in by software maintenance is investigated and analyzed for searching the optimal maintenance policy, which aims at minimizing the average maintenance time cost. The optimality of our proposed policy is shown and checked by numerical examples with discussions of its possible application perspectives. Copyright © 2010 John Wiley & Sons, Ltd.

Search-based software engineering (SBSE) consists of the application of metaheuristic search techniques—such as genetic algorithms, simulated annealing, hill climbing, and tabu search—to software engineering problems. This idea is based on the observation that some software engineering activities can be thought of as optimization problems, and on the fact that techniques providing exact solutions are, very often, unable to adequately scale to large, real-world software engineering problems. Define fitness functions to guide an automated search for solutions, rather than attempting to construct solutions from scratch by hand. SBSE moves the engineer up the abstraction chain, from the tedious and expensive role of detailed solution construction, to the potentially more productive and more cost-effective area of fitness function design. This approach has been repeatedly demonstrated to have successful applications across the software engineering life cycle from requirements and project planning to maintenance and testing. This special issue focuses on applications of search SBSE to the maintenance phase of the life cycle. After software testing 2, software maintenance is the most widely studied application area for SBSE research. Work on SBSE applications to problems in software maintenance can be traced back to the pioneering work of the Mancoridis et al. 3, which led to the development of the Bunch tool for software re-modularization 4. In the past five years there has been a significant increase in SBSE applications to software maintenance and evolution. Search-based techniques have been applied to post-development code improvement problems, such as object-oriented refactoring 5, 6, and imperative language slicing and transformation 7. Other applications are related to software engineering economics and project management problems, such as release planning 8-12, effort, and cost estimation 13-16, and project staffing and planning 17-20. Last, but not the least, SBSE has been applied to deal with service-oriented architectures, for example for services QoS-aware composition 21, service-level agreement negotiation 22, and testing 23. A complete overview of SBSE with a discussion of future research trends can be found in the recent International Conference on Software Engineering (ICSE) ‘Future of Software Engineering’ paper 24. This issue of the Journal of Software Maintenance and Evolution: Research and Practice features three outstanding papers, dealing with different aspects of software maintenance and evolution: release planning and staffing, re-factoring, and component substitution. The paper ‘Optimized Staffing for Product Releases—Focused Search and its Application at Chartwell Technologies’ by Puneet Kapur, An Ngo-The, Günther Ruhe, and Andrew Smith presents an approach for optimizing the staffing for product releases. The problem they solve can be viewed as part of the more general release planning problem, which assigns features to releases such that technical, resource, risk, and budget constraints are met. In particular, the genetic search-based approach the authors propose aims at assigning human resources to software development tasks, taking them from a pool of developers having different levels of skills. The applicability of the proposed approach is demonstrated with an industrial case study. The paper ‘Search-Based Refactoring: an Empirical Study’ by Mark O'Keffe and Mel Ó Cinnéide presents an approach to automatically re-factor, using search-based techniques, object-oriented systems that undergo repeated addition of functionality. Such addition can, very often, deteriorate the quality of the system's underlying design. Their re-factoring is guided by the QMOOD quality model 25, and the paper compares different optimization techniques, such as Genetic Algorithms, Simulated Annealing, and Multiple Ascent Hill-Climbing. The results of experiments carried out on five software systems suggest that the latter technique outperforms the others. The paper ‘Search-based Many-to-one Component Substitution’ by Nicolas Desnos, Marianne Huchard, Guy Tremblay, Christelle Urtado, and Sylvain Vauttier presents a search-based approach that allows the replacement of an obsolete component with a composition of multiple components. When a component becomes obsolete, the approach searches for a minimal assembly of other components, exposing their functionality by means of ports that preserves the behavior of the original component. The proposed approach has been evaluated on a set of randomly generated components. We hope that readers will enjoy this special issue and find the selected papers insightful and inspiring. We would like to thank all the authors who presented papers for this special issue: there were many good quality papers, but unfortunately we could accept only three of them. Last, but not the least, we would like to thank the reviewers who provided timely, detailed and constructive feedbacks to the authors. Without their precious help this special issue would not have been possible.

Automatic and semi-automatic approaches supporting program comprehension are sought by researchers and practitioners to facilitate software engineering tasks, such as development, maintenance, extension and so on. Using topic modeling is a promising way to automatically discover feature and structure from textual software assets. However, there are gaps between knowing and doing when applying topic modeling to software engineering practice. In this paper, we explored how to infuse topic modeling into understanding Java programs in a generic level, and summarized the whole procedure as a methodology called MAT. MAT utilizes essential information automatically generated from Java projects to establish a project overview and to bring search capability for software engineers. Experiments on two open source Java projects suggest that MAT can support program comprehension for Java software engineers during carrying on software maintenance and extension tasks.

A software is developed to satisfy some requirements that could change with respect to technology progress or new clients needs. That is why a software evolves continually in order to fit with occurring requirements. Software evolution or maintenance represents a non-trivial issue that should be treated seriously. In fact, according to some studies software maintenance could consume about 80% of software development total cost. In most of works, such issue was treated in a source code level by proposing new techniques and tools that could optimize maintenance cost. In this paper, we treat the same issue but in an earlier phase of software development and exactly in software design. We propose here an UML profile that allows to software developers and designers to carry about maintenance tasks at the design phase in order to predict handling maintenance tasks before happening, to get an historical trace of these tasks and to express explicitly on models some design patterns helping to resolve software maintenance problems in order to make maintenance easier and cheaper.

Semantic Web was proposed to make the content machine-understandable by developing ontologies to capture domain knowledge and annotating content with this domain knowledge. Although, the original idea of semantic web was to make content on the World Wide Web machine-understandable, with recent advancements and awareness about these technologies, researchers have applied ontologies in many interesting domains. Many phases in software engineering are dependent on availability of knowledge, and the use of ontologies to capture and process this knowledge is a natural choice. This chapter discusses how ontologies can be used in various stages of the system development life cycle. Ontologies can be used to support requirements engineering phase in identifying and fixing inconsistent, incomplete, and ambiguous requirement. They can also be used to model the requirements and assist in requirements management and validation. During software design and development stages, ontologies can help software engineers in finding suitable components, managing documentation of APIs, and coding support. Ontologies can help in system integration and evolution process by aligning various databases with the help of ontologies capturing knowledge about database schema and aligning them with concepts in ontology. Ontologies can also be used in software maintenance by developing a bug tracking system based upon ontological knowledge of software artifacts and roles of developers involved in software maintenance task.

Self-Admitted Technical Debt (SATD) is primarily studied in Object-Oriented (OO) languages and traditionally commercial software. However, scientific software coded in dynamically-typed languages such as R differs in paradigm, and the source code comments’ semantics are different (i.e., more aligned with algorithms and statistics when compared to traditional software). Additionally, many Software Engineering topics are understudied in scientific software development, with SATD detection remaining a challenge for this domain. This gap adds complexity since prior works determined SATD in scientific software does not adjust to many of the keywords identified for OO SATD, possibly hindering its automated detection. Therefore, we investigated how classification models (traditional machine learning, deep neural networks, and deep neural Pre-Trained Language Models (PTMs)) automatically detect SATD in R packages. This study aims to study the capabilities of these models to classify different TD types in this domain and manually analyze the causes of each in a representative sample. Our results show that PTMs (i.e., RoBERTa) outperform other models and work well when the number of comments labelled as a particular SATD type has low occurrences. We also found that some SATD types are more challenging to detect. We manually identified sixteen causes, including eight new causes detected by our study. The most common cause was failure to remember, in agreement with previous studies. These findings will help the R package authors automatically identify SATD in their source code and improve their code quality. In the future, checklists for R developers can also be developed by scientific communities such as rOpenSci to guarantee a higher quality of packages before submission.

Software maintenance has been recognized by academicians and practitioners from industry as the most challenging and expensive part in software life cycle. The complexity and high costs of maintenance activities require systematic evidence of all maintenance activities and accurate models for planning and managing them. A common way for analyzing practice in software engineering is based on trend analysis of historical data related to activities and tasks implemented in the past. This paper presents a case study conducted in a micro software company aimed at introducing a schema for classifying maintenance tasks, and identifying trends in software maintenance tasks distribution among the programmers in the company. The discussion of results includes benefits for the company, limitations of the research and implications for academicians and practitioners in industry. The paper concludes with a few promising further research directions.

Internet code search is quite popular research area. StackOverflow allows developers to ask and answer questions about code. Previous approach to search code on StackOverflow uses tf-idf method that based on number of occurrences of words to recommend source code. This method has the disadvantage that variable or method identifiers are considered as normal words, even though identifiers are often a combination of two or more words. For example, there is an identifier named “randomString”. In that case, if we search using a keyword “random” the system probably will not recommend “randomString” because both words are different. Concept location can tackle this problem. Concept location has been used widely to obtain the correlation between code with a specific concepts or features. Previous research of concept location only focused on source code's comments, and relation among the objects within the source code. This research proposes a mechanism for finding code on StackOverflow uses Latent Dirichlet Allocation (LDA) using concept location in the preprocessing stage. Questions, answers, and code snippets about Java programming are downloaded from StackOverflow to a local repository. Corpuses are generated by extracting questions, answers and code snippets. Inferencing concept location from source code is created using LDA algorithm. Developers query concepts and then system will recommend source code based on the relevant concepts. The result of the experiment shows that the system is able to recommend source code with 48% average of precision and 58% average of recall.

Software engineering, in applying engineering to software, advocates the application of systematic, disciplined, quantifiable approaches to development, operation, and maintenance of software. Software engineering is also considered a transformational process that models the real world on a corresponding software world. Recent advances in software engineering applied to Web intelligence have been recognized as a wave in scientific research and development, exploring basic roles and practical impact of advanced information technology on next-generation Web-empowered products, systems, and services. Various web systems and services currently provide many benefits to users, with Web intelligence becoming increasingly important in research and business. Such Web intelligent systems have been realized through related technologies as software engineering, interactive machine learning, etc. This special issue brings together researchers who have inspired software engineering in Web intelligence. Submissions have been reviewed for relevance, originality, significance, and presentation based on JACIII review criteria. This special issue presents four papers describing outstanding studies on project management, service-oriented architecture, semantic Web technologies, and service composition planning in Web intelligence. All papers introduce promising approaches and interesting results that readers will find highly relevant! We believe that software engineering in Web Intelligence has tremendous potential as a new, active research field, and we hope this issue will motivate researchers to expand their own studies on software engineering in Web Intelligence.

An empirical study of software maintenance tasks was carried out in a large Norwegian organization in the period 1992–93. More than one hundred randomly selected maintenance tasks were studied through interviews with the maintainers performing the tasks immediately before they started the tasks and immediately after they had completed the tasks. The collected data is used to develop distributions and to test 33 hypotheses about software maintenance. The findings from the study indicate, for example, that Application system documentation plays only a minor role as maintenance information source. The maintenance productivity, measured in LOC/effort, is predicted by the size of the task and type of change in the source code, but seems rather independent of language level, maintainer experience, application age and application size. There is an economy of scale for software maintenance tasks. The type of programming language does not correlate with proportion of unexpected maintenance problems, task complexity or task size. The proportion of corrective maintenance decreases with increasing age of the application.

Introduction The computing sciences are complex fields that combine both theoretical and practical components. Students successfully completing an undergraduate computer science program should have instruction in both the mathematical and theoretical foundations of computing as well as the more practical aspects of how to effectively use computers to solve problems. Software engineering, as its name implies, is more directed toward the practical aspects of how to successfully develop complex systems that meet user requirements and are reliable, usable, and maintainable. Computing Curricula 2005 recognizes the need for more extensive education to produce professional engineers than what can be reasonably provided in a typical computer science program (ACM, 2005). As such, they propose engineering be treated as a totally separate discipline within computer science education. However, while there has been some debate about the exact role engineering should have in a computer science program (Curran, 2003), the ACM Curricula has maintained the importance of engineering to all computer science students and has kept it as a core element in computer science education (ACM, 2008). For purposes of this paper, we will focus on the teaching of engineering within the computer science discipline. Unlike other topics in the computer science major, the techniques and principles taught in engineering are often first developed and refined in industry before arriving in the classroom. As commercial development techniques and tools evolve, so pedagogical methodologies change. Computer science educators have taken different approaches to teaching engineering over the years, both as a result of changing methodologies as well as individual beliefs about what teaching methods work best in a particular academic environment. This paper is a case study in applying current productivity tools (specifically Redmine) in a engineering course at our institution. The objectives of the study are to investigate how to integrate the tools into the existing structure and evaluate their impact. We describe our experience in recently changing our approach to teaching engineering to be more aligned with current tools and how to effectively use them in an academic environment. The paper begins with an overview of engineering teaching methods, then describes our traditional approach and motivation for changing, how the new approach was integrated into the course, our experience with the change, and, finally, our plans for the future Software Engineering Education Background Software Engineering is defined as the application of a systematic, disciplined, quantifiable approach to the development, operation and maintenance of software (Petkovic, Thompson, & Todtenhoefer, 2006, p. 294). The need to teach engineering in colleges has been identified for decades. Stiller & LeBlanc (2002) point out as far back as the early 1990's, ACM Computing Curricula suggested that the at least one engineering course should be required in accredited computer science programs. They point out that the number of large projects in industry demand this and suggest that the proof of the success of these accredited computer science programs should be seen in the reduction of failure in the design and operation of large computer programs. Software engineering programs can be thought of as a replacement for the old apprenticeship programs which taught the trades to workman (Stroulia, Bauer, Craig, Reid, & Wilson, 2011). The issue, however, is how to bring this effect into the classroom. Many educators feel that current practices of teaching engineering are not adequately preparing students for the real world of development. Nurkkala & Brandle (2011) summarize the problems with current teaching approaches: * No product--students are creating projects, not commercial grade products * Short duration--single semester, or two-semester, courses impose an artificial time constraint * High turnover--new students each semester means the talent pool remains shallow and student skills are not developing based on previous experience * Low complexity--by necessity given time constraints and skill sets * No maintenance--as a result of short duration, students do not experience a key aspect of development, the maintenance phase * No customer--most engineering projects do not interface with a real customer To address these shortcomings, different approaches to teaching engineering have emerged and been proposed in the literature. …

Software maintainers have long been acutely aware of the challenges involved in managing software change processes. Activities such as software migration, restructuring and reengineering all involve source code modification. They rely heavily on analysis and comprehension of the complex system structures and interactions that characterize both legacy and modern software systems. It is widely accepted that tools that support software analysis and maintenance tasks would go a long way towards addressing the constraints that software developers and maintainers work with on a day-to-day basis. Nevertheless, despite an abundance of tools, not many are used by practitioners and very few are considered essential for a particular development or maintenance task. This workshop examined design issues related to the development and application of tools to support software analysis and maintenance

One of the most frequent problems faced by software maintainers is to find the location of the code related with specific features. This is a costly task because features tend to be scattered in the code. Considering this problem, several approaches for locating features using dynamic analysis have been developed. Nonetheless, the use of dynamic analysis is not fully incorporated in the daily practice of software maintainers. Empirical studies that reveal strengths and weaknesses of the use dynamic analysis in maintenance tasks can bring better understanding of this problem. This study contributes with an empirical assessment of the use of execution traces on software maintenance. We report on a controlled experiment performed with developers when they were performing actualmaintenance activities on systems of different sizes. There are benefits related with a systematic use of execution traces by reducing the execution time and increasing the correction of the developer task during software maintenance. Also, a lower level of difficulty of the tasks was perceived by the participants using dynamic information. Another conclusion is that the approach seems to be useless in maintenance activities where the problem of feature scattering does not occur clearly. This study also reveals that there are still some challenges related to false negatives.