waashk/dblp huggingface dataset:
an empirical study of the effects of conscientiousness in pair programming using the five-factor personality model. this paper describes a formal experiment carried out to investigate the effect of the personality factor conscientiousness on the effectiveness of pair programming as a pedagogical tool in higher education. this experiment took place at the university of auckland, using as subjects undergraduate students attending an introductory programming course. conscientiousness was chosen because it has been shown to be the most consistent predictor of academic achievement. our findings showed that differences in conscientiousness level did not significantly affect the academic performance of students who pair programmed, which could have been due to the short duration of the tasks used throughout the experiment. however, results revealed that another personality factor - openness to experience - presented a significant correlation with paired students' academic performance.
has the bug really been fixed? software has bugs, and fixing those bugs pervades the software engineering process. it is folklore that bug fixes are often buggy themselves, resulting in bad fixes, either failing to fix a bug or creating new bugs. to confirm this folklore, we explored bug databases of the ant, aspectj, and rhino projects, and found that bad fixes comprise as much as 9% of all bugs. thus, detecting and correcting bad fixes is important for improving the quality and reliability of software. however, no prior work has systematically considered this bad fix problem, which this paper introduces and formalizes. in particular, the paper formalizes two criteria to determine whether a fix resolves a bug: coverage and disruption. the coverage of a fix measures the extent to which the fix correctly handles all inputs that may trigger a bug, while disruption measures the deviations from the program's intended behavior after the application of a fix. this paper also introduces a novel notion of distance-bounded weakest precondition as the basis for the developed practical techniques to compute the coverage and disruption of a fix. to validate our approach, we implemented fixation, a prototype that automatically detects bad fixes for java programs. when it detects a bad fix, fixation returns an input that still triggers the bug or reports a newly introduced bug. programmers can then use that bug-triggering input to refine or reformulate their fix. we manually extracted fixes drawn from real-world projects and evaluated fixation against them: fixation successfully detected the extracted bad fixes.
measuring complexity, effectiveness and efficiency in software course projects. this paper discusses results achieved in measuring complexity, effectiveness and efficiency, in a series of related software course projects, spanning a period of seven years. we focus on how the complexity of those projects was measured, and how the success of the students in effectively and efficiently taming that complexity was assessed. this required defining, collecting, validating and analyzing several indicators of size, effort and quality; their rationales, advantages and limitations are discussed. the resulting findings helped to improve the process itself.
test generation through programming in udita. we present an approach for describing tests using non-deterministic test generation programs. to write such programs, we introduce udita, a java-based language with non-deterministic choice operators and an interface for generating linked structures. we also describe new algorithms that generate concrete tests by efficiently exploring the space of all executions of non-deterministic udita programs. we implemented our approach and incorporated it into the official, publicly available repository of java pathfinder (jpf), a popular tool for verifying java programs. we evaluate our technique by generating tests for data structures, refactoring engines, and jpf itself. our experiments show that test generation using udita is faster and leads to test descriptions that are easier to write than in previous frameworks. moreover, the novel execution mechanism of udita is essential for making test generation feasible. using udita, we have discovered a number of bugs in eclipse, netbeans, sun javac, and jpf.
archface: a contract place where architectural design and code meet together. this paper proposes archface, an interface mechanism for bridging the gap between architectural design and its implementation. archface, which encapsulates design essence based on the component-and-connector architecture, is not only an adl (architecture description language) but also a programming-level interface. archface is effective for software evolution because traceability between design and its implementation can be realized by enforcing architectural constraints on program implementation, and this traceability is bidirectional. in archface, a component exposes program points such as method call/execution and a connector defines how to coordinate exposed program points. a collaborative architecture consisting of components can be encapsulated into a group of interfaces and separated from implementation, because dynamic program points representing control flow can be specified in the interfaces. we can characterize the notion of archface with the phrase "predicate coordination," in which program points are exposed by a predicate and coordinated by a trait-based connector.
leakpoint: pinpointing the causes of memory leaks. most existing leak detection techniques for c and c++ applications only detect the existence of memory leaks. they do not provide any help for fixing the underlying memory management errors. in this paper, we present a new technique that not only detects leaks, but also points developers to the locations where the underlying errors may be fixed. our technique tracks pointers to dynamically-allocated areas of memory and, for each memory area, records several pieces of relevant information. this information is used to identify the locations in an execution where memory leaks occur. to investigate our technique's feasibility and usefulness, we developed a prototype tool called leakpoint and used it to perform an empirical evaluation. the results of this evaluation show that leakpoint detects at least as many leaks as existing tools, reports zero false positives, and, most importantly, can be effective at helping developers fix the underlying memory management errors.
an empirical study of optimizations in yogi. though verification tools are finding industrial use, the utility of engineering optimizations that make them scalable and usable is not widely known. despite the fact that several optimizations are part of folklore in the communities that develop these tools, no rigorous evaluation of these optimizations has been done before. we describe and evaluate several engineering optimizations implemented in the yogi property checking tool, including techniques to pick an initial abstraction, heuristics to pick predicates for refinement, optimizations for interprocedural analysis, and optimizations for testing. we believe that our empirical evaluation gives the verification community useful information about which optimizations they could implement in their tools, and what gains they can realistically expect from these optimizations.
developers ask reachability questions. a reachability question is a search across feasible paths through a program for target statements matching search criteria. in three separate studies, we found that reachability questions are common and often time consuming to answer. in the first study, we observed 13 developers in the lab and found that half of the bugs developers inserted were associated with reachability questions. in the second study, 460 professional software developers reported asking questions that may be answered using reachability questions more than 9 times a day, and 82% rated one or more as at least somewhat hard to answer. in the third study, we observed 17 developers in the field and found that 9 of the 10 longest activities were associated with reachability questions. these findings suggest that answering reachability questions is an important source of difficulty understanding large, complex codebases.
a degree-of-knowledge model to capture source code familiarity. the size and high rate of change of source code comprising a software system make it difficult for software developers to keep up with who on the team knows about particular parts of the code. existing approaches to this problem are based solely on authorship of code. in this paper, we present data from two professional software development teams to show that both authorship and interaction information about how a developer interacts with the code are important in characterizing a developer's knowledge of code. we introduce the degree-of-knowledge model that computes automatically a real value for each source code element based on both authorship and interaction information. we show that the degree-of-knowledge model can provide better results than an existing expertise finding approach and also report on case studies of the use of the model to support knowledge transfer and to identify changes of interest.
developing next generation adls through mde techniques. despite the flourishing of languages to describe software architectures, existing architecture description languages (adls) are still far away from what it is actually needed. in fact, while they support a traditional perception of a software architecture (sa) as a set of constituting elements (such as components, connectors and interfaces), they mostly fail to capture multiple stakeholders concerns and their design decisions that represent a broader view of sa being accepted today. next generation adls must cope with various and ever evolving stakeholder concerns by employing semantic extension mechanisms. in this paper we present a framework, called byadl - build your adl, for developing a new generation of adls. byadl exploits model-driven techniques that provide the needed technologies to allow a software architect, starting from existing adls, to define its own new generation adl by: i) adding domain specificities, new architectural views, or analysis aspects, ii) integrating adls with development processes and methodologies, and iii) customizing adls by fine tuning them. the framework is put in practice in different scenarios showing the incremental extension and customization of the darwin adl.
a machine learning approach for tracing regulatory codes to product specific requirements. regulatory standards, designed to protect the safety, security, and privacy of the public, govern numerous areas of software intensive systems. project personnel must therefore demonstrate that an as-built system meets all relevant regulatory codes. current methods for demonstrating compliance rely either on after-the-fact audits, which can lead to significant refactoring when regulations are not met, or else require analysts to construct and use traceability matrices to demonstrate compliance. manual tracing can be prohibitively time-consuming; however automated trace retrieval methods are not very effective due to the vocabulary mismatches that often occur between regulatory codes and product level requirements. this paper introduces and evaluates two machine-learning methods, designed to improve the quality of traces generated between regulatory codes and product level requirements. the first approach uses manually created traceability matrices to train a trace classifier, while the second approach uses web-mining techniques to reconstruct the original trace query. the techniques were evaluated against security regulations from the usa government's health insurance privacy and portability act (hipaa) traced against ten healthcare related requirements specifications. results demonstrated improvements for the subset of hipaa regulations that exhibited high fan-out behavior across the requirements datasets.
code bubbles: rethinking the user interface paradigm of integrated development environments. today's integrated development environments (ides) are hampered by their dependence on files and file-based editing. we propose a novel user interface that is based on collections of lightweight editable fragments, called bubbles, which when grouped together form concurrently visible working sets. in this paper we describe the design of a prototype ide user interface for java based on working sets. a quantitative evaluation shows that developers could expect to view a sizeable number of functions concurrently with relatively few ui operations. a qualitative user evaluation with 23 professional developers indicates a high level of excitement, interest, and potential benefits and uses.
adaptive bug isolation. statistical debugging uses lightweight instrumentation and statistical models to identify program behaviors that are strongly predictive of failure. however, most software is mostly correct; nearly all monitored behaviors are poor predictors of failure. we propose an adaptive monitoring strategy that mitigates the overhead associated with monitoring poor failure predictors. we begin by monitoring a small portion of the program, then automatically refine instrumentation over time to zero in on bugs. we formulate this approach as a search on the control-dependence graph of the program. we present and evaluate various heuristics that can be used for this search. we also discuss the construction of a binary instrumentor for incorporating the feedback loop into post-deployment monitoring. performance measurements show that adaptive bug isolation yields an average performance overhead of 1% for a class of large applications, as opposed to 87% for realistic sampling-based instrumentation and 300% for complete binary instrumentation.
views: object-inspired concurrency control. we present views, a new approach to controlling concurrency. fine-grained locking is often necessary to increase concurrency. correctly implementing fine-grained locking with today's concurrency primitives can be challenging---race conditions often plague programs with sophisticated locking schemes. views ease the task of implementing sophisticated locking schemes and provide static checks to automatically detect many data races. views consist of view declarations that describe which views of an object may be simultaneously held by different threads, which object fields may be accessed through a given view, and which methods can be called through a given view. a set of view annotations specify which code regions hold a view of an object. our view compiler performs simple static checks which eliminate many data races. we have ported three benchmark applications to use views: portions of vuze, a bittorrent client; mailpuccino, a graphical e-mail client; and tuplesoup, a database. our experience indicates that views are easy to use, make implementing sophisticated locking schemes simple, and can help eliminate concurrency bugs.
an empirical analysis of team review approaches for teaching quality software development. reviews are an integral part of the software development process. they are one of the key methodologies that undergraduates study in order to develop quality software. despite their importance, reviews are rarely used in software engineering projects at the baccalaureate level. this paper demonstrates results from a study conducted on students at baccalaureate level enrolled in a one-semester software engineering course at the national university of computer and emerging sciences -- foundation for advancement of science and technology (nuces-fast) in pakistan. the objectives of the study are: to determine how the various team review techniques help to educate students about the importance of the review process and find which technique is more suitable for teaching reviews to undergraduates. two variations on team review are proposed: similar domain review (sdr) and cross-domain review (cdr) without author. the paper presents a comparison of the proposed and existing team review techniques and measures their effectiveness in terms of defect detection. the results show that the proposed variation sdr is more effective in defect detection than cdr (with/without author). another interesting result is that the proposed cdr-without author is better than cdr with author (the existing team review approach). also, early defect detection enabled students to incorporate changes and improve the software quality.
online inference and enforcement of temporal properties. the interfaces of software components are often paired with specifications or protocols that prescribe correct and safe usage. an important class of these specifications consists of temporal safety properties over function or method call sequences. because violations of these properties can lead to program crashes or subtly inconsistent program state, these properties are frequently the target of runtime monitoring techniques. however, the properties must be specified in advance, a time-consuming process. recognizing this problem, researchers have proposed various specification inference techniques, but they suffer from imprecision and require a significant investment in developer time. this work presents the first fully automatic dynamic technique for simultaneously learning and enforcing general temporal properties over method call sequences. our technique is an online algorithm that operates over a short, finite execution history. this limited view works well in practice due to the inherent temporal locality in sequential method calls on java objects, a property we validate empirically. we have implemented our algorithm in a practical tool for java, ocd, that operates with a high degree of precision and finds new defects and code smells in well-tested applications.
mining api mapping for language migration. to address business requirements and to survive in competing markets, companies or open source organizations often have to release different versions of their projects in different languages. manually migrating projects from one language to another (such as from java to c#) is a tedious and error-prone task. to reduce manual effort or human errors, tools can be developed for automatic migration of projects from one language to another. however, these tools require the knowledge of how application programming interfaces (apis) of one language are mapped to apis of the other language, referred to as api mapping relations. in this paper, we propose a novel approach, called mam (mining api mapping), that mines api mapping relations from one language to another using api client code. mam accepts a set of projects each with two versions in two languages and mines api mapping relations between those two languages based on how apis are used by the two versions. these mined api mapping relations assist in migration of projects from one language to another. we implemented a tool and conducted two evaluations to show the effectiveness of mam. the results show that our tool mines 25,805 unique mapping relations of apis between java and c# with more than 80% accuracy. the results also show that mined api mapping relations help reduce 54.4% compilation errors and 43.0% defects during migration of projects with an existing migration tool, called java2csharp. the reduction in compilation errors and defects is due to our new mined mapping relations that are not available with the existing migration tool.
summarizing software artifacts: a case study of bug reports. many software artifacts are created, maintained and evolved as part of a software development project. as software developers work on a project, they interact with existing project artifacts, performing such activities as reading previously filed bug reports in search of duplicate reports. these activities often require a developer to peruse a substantial amount of text. in this paper, we investigate whether it is possible to summarize software artifacts automatically and effectively so that developers could consult smaller summaries instead of entire artifacts. to provide focus to our investigation, we consider the generation of summaries for bug reports. we found that existing conversation-based generators can produce better results than random generators and that a generator trained specifically on bug reports can perform statistically better than existing conversation-based generators. we demonstrate that humans also find these generated summaries reasonable indicating that summaries might be used effectively for many tasks.
panel on master's degree programs in software engineering. as software engineering advances, new software engineering programs continue to emerge in universities around the world and existing ones are continually being updated. these programs face myriad challenges such as incorporating new software engineering technologies, recruiting and retaining qualified faculty, attracting students, leveraging new technologies for remote teaching, integrating related disciplines such as systems engineering, and, of course, deciding what basic content to include in their courses. the recently published graduate software engineeing 2009 "gswe2009" (http://www.gswe2009.org) presents a model and guidelines to help faculty address those challenges. both acm and ieee approved and endorsed gswe2009 in 2009. the panel will debate approaches to developing master's programs in software engineering in general and gswe2009 in particular. it will consider experiences, challenges, and criticisms of gswe2009.
effective interprocedural resource leak detection. garbage collection relieves programmers from the burden of explicit memory management. however, explicit management is still required for finite system resources, such as i/o streams, fonts, and database connections. failure to release unneeded system resources results in resource leaks, which can lead to performance degradation and system crashes. in this paper, we present a new tool, tracker, that performs static analysis to find resource leaks in java programs. tracker is an industrial-strength tool that is usable in an interactive setting: it works on millions of lines of code in a matter of minutes and it has a low false positive rate. we describe the design, implementation and evaluation of tracker, focusing on the features that make the tool scalable and its output actionable by the user.
is operator-based mutant selection superior to random mutant selection? due to the expensiveness of compiling and executing a large number of mutants, it is usually necessary to select a subset of mutants to substitute the whole set of generated mutants in mutation testing and analysis. most existing research on mutant selection focused on operator-based mutant selection, i.e., determining a set of sufficient mutation operators and selecting mutants generated with only this set of mutation operators. recently, researchers began to leverage statistical analysis to determine sufficient mutation operators using execution information of mutants. however, whether mutants selected with these sophisticated techniques are superior to randomly selected mutants remains an open question. in this paper, we empirically investigate this open question by comparing three representative operator-based mutant-selection techniques with two random techniques. our empirical results show that operator-based mutant selection is not superior to random mutant selection. these results also indicate that random mutant selection can be a better choice and mutant selection on the basis of individual mutants is worthy of further investigation.