Infusing Topic Modeling into Interactive Program Comprehension: An Empirical Study

Background. Refactoring is a critical task in software maintenance and is generally performed to enforce the best design and implementation practices or to cope with design defects. Several studies attempted to detect refactoring activities through mining software repositories allowing to collect, analyze and get actionable data-driven insights about refactoring practices within software projects. Aim. We aim at identifying, among the various quality models presented in the literature, the ones that are more in-line with the developer's vision of quality optimization, when they explicitly mention that they are refactoring to improve them. Method. We extract a large corpus of design-related refactoring activities that are applied and documented by developers during their daily changes from 3,795 curated open source Java projects. In particular, we extract a large-scale corpus of structural metrics and anti-pattern enhancement changes, from which we identify 1,245 quality improvement commits with their corresponding refactoring operations, as perceived by software engineers. Thereafter, we empirically analyze the impact of these refactoring operations on a set of common state-of-the-art design quality metrics. Results. The statistical analysis of the obtained results shows that (i) a few state-of-the-art metrics are more popular than others; and (ii) some metrics are being more emphasized than others. Conclusions. We verify that there are a variety of structural metrics that can represent the internal quality attributes with different degrees of improvement and degradation of software quality. Most of the metrics that are mapped to the main quality attributes do capture developer intentions of quality improvement reported in the commit messages.

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.

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.

Software traceability is a fundamentally important task in software engineering. The need for automated traceability increases as projects become more complex and as the number of artifacts increases. We propose an automated technique that combines traceability with a machine learning technique known as topic modeling. Our approach automatically records traceability links during the software development process and learns a probabilistic topic model over artifacts. The learned model allows for the semantic categorization of artifacts and the topical visualization of the software system. To test our approach, we have implemented several tools: an artifact search tool combining keyword-based search and topic modeling, a recording tool that performs prospective traceability, and a visualization tool that allows one to navigate the software architecture and view semantic topics associated with relevant artifacts and architectural components. We apply our approach to several data sets and discuss how topic modeling enhances software traceability, and vice versa.

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.

Bug reports are widely employed to facilitate software tasks in software maintenance. Since bug reports are contributed by people, the authorship characteristics of contributors may heavily impact the performance of resolving software tasks. Poorly written bug reports may delay developers when fixing bugs. However, no in-depth investigation has been conducted over the authorship characteristics. In this study, we first leverage byte-level $N$-grams to model the authorship characteristics and employ Normalized Simplified Profile Intersection (NSPI) to identify the similarity of the authorship characteristics. Then, we investigate a series of properties related to contributors authorship characteristics, including the evolvement over time and the variation among distinct products in open source projects. Moreover, we show how to leverage the authorship characteristics to facilitate a well-known task in software maintenance, namely Bug Report Summarization (BRS). Experiments on open source projects validate that incorporating the authorship characteristics can effectively improve a state-of-the-art method in BRS. Our findings suggest that contributors should retain stable authorship characteristics and the authorship characteristics can assist in resolving software tasks.

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.

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.

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.

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.

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

Software engineering is a data-driven discipline and an integral part of data science. The introduction of big data systems has led to a great transformation in the architecture, methodologies, knowledge domains, and skills related to software engineering. Accordingly, education programs are now required to adapt themselves to up-to-date developments by first identifying the competencies concerning big data software engineering to meet the industrial needs and follow the latest trends. This paper aims to reveal the knowledge domains and skill sets required for big data software engineering and develop a taxonomy by mapping these competencies. A semi-automatic methodology is proposed for the semantic analysis of the textual contents of online job advertisements related to big data software engineering. This methodology uses the latent Dirichlet allocation (LDA), a probabilistic topic-modeling technique to discover the hidden semantic structures from a given textual corpus. The output of this paper is a systematic competency map comprising the essential knowledge domains, skills, and tools for big data software engineering. The findings of this paper are expected to help evaluate and improve IT professionals' vocational knowledge and skills, identify professional roles and competencies in personnel recruitment processes of companies, and meet the skill requirements of the industry through software engineering education programs. Additionally, the proposed model can be extended to blogs, social networks, forums, and other online communities to allow automatic identification of emerging trends and generate contextual tags.

Approaches that support software maintenance need to be evaluated and compared against existing ones, in order to demonstrate their usefulness in practice. However, oftentimes the lack of well-established sets of benchmarks leads to situations where these approaches are evaluated using different datasets, which results in biased comparisons. In this data paper we describe and make publicly available a set of benchmarks from six Java applications, which can be used in the evaluation of various software engineering (SE) tasks, such as feature location and impact analysis. These datasets consist of textual description of change requests, the locations in the source code where they were implemented, and execution traces. Four of the benchmarks were already used in several SE research papers, and two of them are new. In addition, we describe in detail the methodology used for generating these benchmarks and provide a suite of tools in order to encourage other researchers to validate our datasets and generate new benchmarks for other subject software systems. Our online appendix: http://www.cs.wm.edu/semeru/data/msr13/.

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. …

Context: In the last years, the Grey Literature (GL) had a notable increase in interest in diverse areas of knowledge. In Software Engineering (SE), with the advance of social media, the SE practitioners are heavy consumers of GL, opposite to traditional research papers, such as the Systematic Literature Review (SLR). Problem: Despite the increase of numbers of SLRs, some researchers claim the lack of connection to the practice of SE, due to the lack of evidence derived from SE practitioners. Goal: Introduce methods and techniques to support a Grey Literature Review (GLR) in SE, aiming to approximate the literature review to the practice of SE. Method: First, we will investigate how secondary studies use GL; Second, we will employ a survey with researchers of SLRs and SE practitioners; Third, we will analyze the use of GL according to the context; Fourth, we will review the GL source in SE; Finally, we will propose a guideline to help SE researchers and practitioners to conduct the GLR. Preliminary findings: We have initiated the tertiary study conducting the manual (4,875 studies) and automatic (6,279 studies) searches. We eliminated those that were not an article, and also those were not written in English, remaining 8,019 potential studies. Currently, we are applying the inclusion and exclusion criteria.