waashk/dblp huggingface dataset:
an analysis of the variability in forty preprocessor-based software product lines. over 30 years ago, the preprocessor cpp was developed to extend the programming language c by lightweight metaprogramming capabilities. despite its error-proneness and low abstraction level, the preprocessor is still widely used in present-day software projects to implement variable software. however, not much is known about how cpp is employed to implement variability. to address this issue, we have analyzed forty open-source software projects written in c. specifically, we answer the following questions: how does program size influence variability? how complex are extensions made via cpp's variability mechanisms? at which level of granularity are extensions applied? which types of extension occur? these questions revive earlier discussions on program comprehension and refactoring in the context of the preprocessor. to provide answers, we introduce several metrics measuring the variability, complexity, granularity, and types of extension applied by preprocessor directives. based on the collected data, we suggest alternative implementation techniques. our data set is a rich source for rethinking language design and tool support.
the educational value of mapping studies of software engineering literature. we identify three challenges related to the provenance of the material we use in teaching software engineering. we suggest that these challenges can be addressed by using evidence-based software engineering (ebse) and its primary tool of systematic literature reviews (slrs). this paper aims to assess the educational and scientific value of undergraduate and postgraduate students undertaking a specific form of slr called a mapping study. using a case study methodology, we asked three postgraduate students and three undergraduates and their supervisor to complete a questionnaire concerning the educational value of mapping studies and any problems they experienced. students found undertaking a mapping study to be a valuable experience providing both reusable research skills and a good overview of a research topic. postgraduates found it useful as a starting point for their studies. undergraduates reported problems undertaking the study in the required timescales. searching and classifying the literature was difficult.
oracle-guided component-based program synthesis. we present a novel approach to automatic synthesis of loop-free programs. the approach is based on a combination of oracle-guided learning from examples, and constraint-based synthesis from components using satisfiability modulo theories (smt) solvers. our approach is suitable for many applications, including as an aid to program understanding tasks such as deobfuscating malware. we demonstrate the efficiency and effectiveness of our approach by synthesizing bit-manipulating programs and by deobfuscating programs.
customized awareness: recommending relevant external change events. it is often assumed that developers' view of their system and its environment is always consistent with everyone else's; in practice, this assumption can be false, as the developer has little practical control over changes to the environments in which their code will be deployed. to proactively respond to such situations, developers must constantly monitor a flood of information involving changes to the deployment environments; unfortunately, the vast majority of this information is irrelevant to the individual developer, and its sheer volume makes it likely that infrequent change events of relevance are overlooked. as a result, errors may arise at deployment time that the developer does not immediately detect. this paper presents a recommendation approach for filtering the flood of change events on deployment dependencies to those that are most likely to cause problems for the individual developer. the approach is evaluated for its ability to drastically filter irrelevant details, while being unlikely to filter important ones. the relevance of the results is assessed on the basis of deployment problems that would have historically occurred within a set of industrial systems.
supporting developers with natural language queries. the feature list of modern ides is steadily growing and mastering these tools becomes more and more demanding, especially for novice programmers. despite their remarkable capabilities, ides often still cannot directly answer the questions that arise during program comprehension tasks. instead developers have to map their questions to multiple concrete queries that can be answered only by combining several tools and examining the output of each of them manually to distill an appropriate answer. existing approaches have in common that they are either limited to a set of predefined, hardcoded questions, or that they require to learn a specific query language only suitable for that limited purpose. we present a framework to query for information about a software system using guided-input natural language resembling plain english. for that, we model data extracted by classical software analysis tools with an owl ontology and use knowledge processing technologies from the semantic web to query it. we use a case study to demonstrate how our framework can be used to answer queries about static source code information for program comprehension purposes.
detecting atomic-set serializability violations in multithreaded programs through active randomized testing. concurrency bugs are notoriously difficult to detect because there can be vast combinations of interleavings among concurrent threads, yet only a small fraction can reveal them. atomic-set serializability characterizes a wide range of concurrency bugs, including data races and atomicity violations. in this paper, we propose a two-phase testing technique that can effectively detect atomic-set serializability violations. in phase i, our technique infers potential violations that do not appear in a concrete execution and prunes those interleavings that are violation-free. in phase ii, our technique actively controls a thread scheduler to enumerate these potential scenarios identified in phase i to look for real violations. we have implemented our technique as a prototype system assetfuzzer and applied it to a number of subject programs for evaluating concurrency defect analysis techniques. the experimental results show that assetfuzzer can identify more concurrency bugs than two recent testing tools racefuzzer and atomfuzzer.
efficient hybrid typestate analysis by determining continuation-equivalent states. typestate analysis determines whether a program violates a set of finite-state properties. because the typestate-analysis problem is statically undecidable, researchers have proposed a hybrid approach that uses residual monitors to signal property violations at runtime. we present an efficient novel static typestate analysis that is flow-sensitive, partially context-sensitive, and that generates residual runtime monitors. to gain efficiency, our analysis uses precise, flow-sensitive information on an intra-procedural level only, and models the remainder of the program using a flow-insensitive pointer abstraction. unlike previous flow-sensitive analyses, our analysis uses an additional backward analysis to partition states into equivalence classes. code locations that transition between equivalent states are irrelevant and require no monitoring. as we show in this work, this notion of equivalent states is crucial to obtaining sound runtime monitors. we proved our analysis correct, implemented the analysis in the clara framework for typestate analysis, and applied it to the dacapo benchmark suite. in half of the cases, our analysis determined exactly the property-violating program points. in many other cases, the analysis reduced the number of instrumentation points by large amounts, yielding significant speed-ups during runtime monitoring.
from scripts to specifications: the evolution of a flight software testing effort. this paper describes the evolution of a software testing effort during a critical period for the flagship mars science laboratory rover project at the jet propulsion laboratory. formal specification for post-run analysis of log files, using a domain-specific language, logscope, replaced scripted real-time analysis. log analysis addresses the key problems of on-the-fly approaches and cleanly separates specification and execution. mining the test repository suggested the inadequacy of the scripted approach, and encouraged a partly engineer-driven development. logscope development should hold insights for others facing the tight deadlines and reactionary nature of testing for critical projects. logscope received a jpl mariner award for "improving productivity and quality of the msl flight software" and has been discussed as an approach for other flight missions. we note logscope features that most contributed to ease of adoption and effectiveness. logscope is general and can be applied to any software producing logs.
jdf: detecting duplicate bug reports in jazz. both developers and users submit bug reports to a bug repository. these reports can help reveal defects and improve software quality. as the number of bug reports in a bug repository increases, the number of the potential duplicate bug reports increases. detecting duplicate bug reports helps reduce development efforts in fixing defects. however, it is challenging to manually detect all potential duplicates because of the large number of existing bug reports. this paper presents jdf (representing jazz duplicate finder), a tool that helps users to find potential duplicates of bug reports on jazz, which is a team collaboration platform for software development and process management. jdf finds potential duplicates for a given bug report using natural language and execution information.
fourth international workshop on software clones (iwsc). software clones are identical or similar pieces of code. they are often the result of copy--and--paste activities as ad-hoc code reuse by programmers. software clones research is of high relevance for the industry. many researchers have reported high rates of code cloning in both industrial and open-source systems. in this workshop we will explore lines of research that evaluate code clone detection methods, reason about ways to remove clones, assess the effect of clones on maintainablity, track clones' evolution, and investigate the root causes of clones.
design science methodology: principles and practice. design scientists have to balance the demands of methodological rigor that they share with purely curiosity-driven scientists, with the demands of practical utility that they share with utility-driven engineers. balancing these conflicting demands can be conceptually complex and may lead to methodological mistakes. for example, treating a design question as an empirical research question may lead to researcher to omit the identification of the practical problem to solve, to omit the identification of stakeholder-motivated evaluation criteria, or to omit trade-off and sensitivity analysis. this tutorial aims to clear up this methodological mist in the case of software engineering (se) research.
exemplar: executable examples archive. searching for applications that are highly relevant to development tasks is challenging because the high-level intent reflected in the descriptions of these tasks doesn't usually match the low-level implementation details of applications. in this demo we show a novel code search engine called exemplar (executable examples archive) to bridge this mismatch. exemplar takes natural-language query that contains high-level concepts (e.g., mime, data sets) as input, then uses information retrieval and program analysis techniques to retrieve applications that implement these concepts.
feature-oriented requirements modelling. our goal is to develop a method for creating models of functional software requirements in which features are explicit, with a focus on the automotive software domain. in the current state of our proposed method, feature requirements are modelled using state machines that describe changes to a shared domain model.
compose & conquer: modularity for end-users. users have vast amounts of information at their disposal and access to many tools that can compute on that data. often, no particular program can fulfill a user's needs; or, when such a program exists, it may be too obscure for the user to find. when users encounter this problem, they resort to ad-hoc approaches, such as importing and exporting data to different file formats, as a way to piece together disparate features from several different programs. as a result, users end up manually entering and manipulating data, defeating the purpose of automatic computing machines. in this paper, we introduce the concept of a creativity engine, which is like a search engine over the possible links between software libraries. a creativity engine can be used to bring together libraries that were never intended to work together, in way that can bring within users' reach the almost infinite flexibility their machines have to transform data.
failure preventing recommendations. software becomes more and more integral to our lives thus software failures affect more people than ever. failures are not only responsible for billions of dollars lost to industry but can cause lethal accidents. although there has been much research into predicting such failures, those predictions usually concentrate either on the technical or the social level of software development. with the ever growing size of software teams we think that coordination among developers is becoming increasingly more important. therefore, we propose to leverage the combination of both social and technical dimensions to create recommendation upon which developers can act to prevent software failures.
an eclectic approach for change impact analysis. change impact analysis aims at identifying software artifacts being affected by a change. in the past, this problem has been addressed by approaches relying on static, dynamic, and textual analysis. recently, techniques based on historical analysis and association rules have been explored. this paper proposes a novel change impact analysis method based on the idea that the mutual relationships between software objects can be inferred with a statistical learning approach. we use the bivariate granger causality test, a multivariate time series forecasting approach used to verify whether past values of a time series are useful for predicting future values of another time series. results of a preliminary study performed on the samba daemon show that change impact relationships inferred with the granger causality test are complementary to those inferred with association rules. this opens the road towards the development of an eclectic impact analysis approach conceived by combining different techniques.
bpgen: an automated breakpoint generator for debugging. during debugging processes, breakpoints are frequently used to inspect and understand runtime behaviors of programs. although most development environments offer convenient breakpoint facilities, the use of these environments usually requires considerable human efforts in order to generate useful breakpoints. before setting breakpoints or typing breakpoint conditions, developers usually have to make some judgements and hypotheses on the basis of their observations and experience. to reduce this kind of efforts we present a tool, named bpgen, to automatically generate breakpoints for debugging. bpgen uses three well-known dynamic fault localization techniques in tandem to identify suspicious program statements and states, through which both conditional and unconditional breakpoints are generated. bpgen is implemented as an eclipse plugin for supplementing the existing eclipse jdt debugger.
a modeling language's evolution driven by tight interaction between academia and industry. domain specific languages play an important role in model-driven engineering of software-intensive industrial systems. a rich body of knowledge exists on the development of languages, modeling environments, and transformation systems. the understanding of architectural choices for combining these parts into a feasible solution, however, is not particularly deep. we report on an endeavor in the realm of a technology transfer process from academia to industry, where we encountered unexpected influences of the architecture on the modeling language. by examining the evolution of our language and its programming interface, we show that these influences mainly stemmed from practical considerations; for identifying these early on, tight interaction between our research lab and the industrial partner was key. in addition, we share insights into the practice of cooperating with industry by presenting essential lessons we learned.
web2se: first workshop on web 2.0 for software engineering. social software is built around an "architecture of participation" where user data is aggregated as a side-effect of using web 2.0 applications. web 2.0 implies that processes and tools are socially open, and that content can be used in several different contexts. web 2.0 tools and technologies support interactive information sharing, data interoperability and user centered design. for instance, wikis, blogs, tags and feeds help us organize, manage and categorize content in an informal and collaborative way. one goal of this workshop is to investigate how these technologies can improve software development practices. some of these technologies have made their way into collaborative software development processes such as agile and scrum, and in development platforms such as rational team concert which draw their inspiration from web 2.0. these processes and environments are just scratching the surface of what can be done by incorporating web 2.0 approaches and technologies into collaborative software development. this workshop aims to improve our understanding of how web 2.0, manifested in technologies such as mashups or dashboards, can change the culture of collaborative software development.
bayesian methods for data analysis in software engineering. software engineering researchers analyze programs by applying a range of test cases, measuring relevant statistics and reasoning about the observed phenomena. though the traditional statistical methods provide a rigorous analysis of the data obtained during program analysis, they lack the flexibility to build a unique representation for each program. bayesian methods for data analysis, on the other hand, allow for flexible updates of the knowledge acquired through observations. despite their strong mathematical basis and obvious suitability to software analysis, bayesian methods are still largely under-utilized in the software engineering community, primarily because many software engineers are unfamiliar with the use of bayesian methods to formulate their research problems. this tutorial will provide a broad introduction of bayesian methods for data analysis, with a specific focus on problems of interest to software engineering researchers. in addition, the tutorial will provide an in-depth understanding of a subset of popular topics such as bayesian inference, probabilistic prediction techniques, markov models, information theory and sampling. the core concepts will be explained using case studies and the application of prominent statistical tools on examples drawn from software engineering research. at the end of the tutorial, the participants will acquire the necessary skills and background knowledge to formulate their research problems using bayesian methods, and analyze their formulation using appropriate software tools.
emfstore: a model repository for emf models. models need to be put under version control to facilitate collaboration and to control change. emfstore is a software configuration management system tailored to the specific requirements for versioning models. it employs operation-based change tracking, conflict detection and merging.
raw: runtime automatic workarounds. faults in web apis may escape the testing process, and therefore affect thousands of web applications. as a consequence, users of these applications might suffer from related failures for a long time until proper fixes are released by the web api developers. in this paper we present raw, a tool that tries to find workarounds automatically and at runtime, thereby reducing the negative impact of faults in web applications. runtime and automatically deployed workarounds serve as a temporary relief for application users while proper fixes are developed and released.
cuta4uml: bridging the gap between informal and formal requirements for dynamic system aspects. in this paper, we describe our integrated approach to improve requirements elicitation and system specification by supporting a strong and direct involvement of all stakeholders, including non technical personnel, in the early phases of a project. this so-called cuta4uml approach comprises a framework of methods, tools and feedback cycles that is based on the concept of participatory design (pd) and instantiated via an extended version of a user-driven "card game" (cuta). this card game can be executed on paper or via electronic means. our focus will be on the system's dynamic aspects which are, always, especially tricky to cover. we will also take a closer look at the inherently involved problem to match the rather informal results of such an card-based approach to a quite formal (uml -- activity diagrams) modeling technique -- a step necessary to make the results useful in a structured development process and, so far, one of the weak points in all of these approaches. all our concepts and conclusions are based on a sound experimental basis and have been evaluated and discussed with industrial partners, mostly in a context of small and medium sized companies.
the "physics" of notations: a scientific approach to designing visual notations in software engineering. visual notations form an integral part of the language of software engineering (se). yet historically, se researchers and notation designers have ignored or undervalued issues of visual representation. in evaluating and comparing notations, details of visual syntax are rarely discussed. in designing notations, the majority of effort is spent on semantics, with graphical conventions often an afterthought. typically no design rationale, scientific or otherwise, is provided for visual representation choices. while se has developed mature methods for evaluating and designing semantics, it lacks equivalent methods for visual syntax. this tutorial defines a set of principles for designing cognitively effective visual notations: ones that are optimised for human communication and problem solving. together these form a design theory, called the physics of notations as it focuses on the physical (perceptual) properties of notations rather than their logical (semantic) properties. the principles were synthesised from theory and empirical evidence from a wide range of fields and rest on an explicit theory of how visual notations communicate. they can be used to evaluate, compare and improve existing visual notations as well as to construct new ones. the tutorial identifies serious design flaws in some of the leading se notations together with practical suggestions for improving them. it also showcases some examples of visual notation design excellence from se and other fields.