waashk/dblp huggingface dataset:
collaborative reliability prediction of service-oriented systems. service-oriented architecture (soa) is becoming a major software framework for building complex distributed systems. reliability of the service-oriented systems heavily depends on the remote web services as well as the unpredictable internet. designing effective and accurate reliability prediction approaches for the service-oriented systems has become an important research issue. in this paper, we propose a collaborative reliability prediction approach, which employs the past failure data of other similar users to predict the web service reliability for the current user, without requiring real-world web service invocations. we also present a user-collaborative failure data sharing mechanism and a reliability composition model for the service-oriented systems. large-scale real-world experiments are conducted and the experimental results show that our collaborative reliability prediction approach obtains better reliability prediction accuracy than other approaches.
beyond hacking: an sos! cyber-security today is focused largely on defending against known attacks. we learn about the latest attack and find a hack to defend against it. so our defenses improve only after they have been successfully penetrated. this is a recipe to ensure some attackers succeed---not a recipe for achieving system trustworthiness. we must move beyond reacting to yesterday's attacks and instead start building systems whose trustworthiness derives from first principles. yet today we lack the understanding to adopt that proactive approach; it's not only a matter of engineering, but we lack a science of security (sos). the sos landscape would includes attacks, defense mechanisms, and security properties; the science would characterize how these relate. what security properties can be preserved by a given defense mechanism? what attacks are resisted by a given mechanism? how can enforcement mechanisms be viewed as "trust relocators"? some challenges are reminiscent of problems that software engineering researchers confront; others resemble problems addressed in the fault-tolerance community. in fact, there are significant technical differences for an sos, deriving from the very different assumptions about requirements and the environment. this talk will attempt clarify the differences. we will also survey recent and promising avenues toward building a sos and creating a principled basis for the engineering of trustworthy systems.
software traceability with topic modeling. 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.
using twinning to adapt programs to alternative apis. we describe twinning and its applications to adapting programs to alternative apis. twinning is a simple technique that allows programmers to specify a class of program changes, in the form of a mapping, without modifying the target program directly. using twinning, programmers can specify changes that transition a program from using one api to using an alternative api. we describe two related mapping-based source-to-source transformations. the first applies the mapping to a program, producing a copy with the changes applied. the second generates a new api that abstracts the changes specified in the mapping. using this api, programmers can invoke either the old (replaced) code or the new (replacement) code through a single interface. managing program variants usually involves heavyweight tasks that can prevent the program from compiling for extended periods of time, as well as simultaneous maintenance of multiple implementations, which can make it easy to forget to add features or to fix bugs symmetrically. our main contribution is to show that, at least in some common cases, the heavyweight work can be reduced and symmetric maintenance can be at least encouraged, and often enforced.
a search engine for finding highly relevant applications. a fundamental problem of finding applications that are highly relevant to development tasks is the mismatch between the high-level intent reflected in the descriptions of these tasks and low-level implementation details of applications. to reduce this mismatch we created an approach called exemplar (executable examples archive) for finding highly relevant software projects from large archives of applications. after a programmer enters a natural-language query that contains high-level concepts (e.g., mime, data sets), exemplar uses information retrieval and program analysis techniques to retrieve applications that implement these concepts. our case study with 39 professional java programmers shows that exemplar is more effective than sourceforge in helping programmers to quickly find highly relevant applications.
an empirical study of reported bugs in server software with implications for automated bug diagnosis. reproducing bug symptoms is a prerequisite for performing automatic bug diagnosis. do bugs have characteristics that ease or hinder automatic bug diagnosis? in this paper, we conduct a thorough empirical study of several key characteristics of bugs that affect reproducibility at the production site. we examine randomly selected bug reports of six server applications and consider their implications on automatic bug diagnosis tools. our results are promising. from the study, we find that nearly 82% of bug symptoms can be reproduced deterministically by re-running with the same set of inputs at the production site. we further find that very few input requests are needed to reproduce most failures; in fact, just one input request after session establishment suffices to reproduce the failure in nearly 77% of the cases. we describe the implications of the results on reproducing software failures and designing automated diagnosis tools for production runs.
a cut-off approach for bounded verification of parameterized systems. the features in multi-threaded programs, such as recursion, dynamic creation and communication, pose a great challenge to formal verification. a widely adopted strategy is to verify tentatively a system with a smaller size, by limiting the depth of recursion or the number of replicated processes, to find errors without ensuring the full correctness. the model checking of parameterized systems, a parametric infinite family of systems, is to decide if a property holds in every size instance. there has been a quest for finding cut-offs for the verification of parameterized systems. the basic idea is to find a cut-off on the number of replicated processes or on the maximum length of paths needed to prove a property, standing a chance of improving verification efficiency substantially if one can come up with small or modest cut-offs. in this paper, a novel approach, called forward bounded reachability analysis (fbra), based upon the cut-off on the maximum lengths of paths is proposed for the verification of parameterized systems. experimental results show that verification efficiency has been significantly improved as a result of the introduction of our new cut-offs.
aura: a hybrid approach to identify framework evolution. software frameworks and libraries are indispensable to today's software systems. as they evolve, it is often time-consuming for developers to keep their code up-to-date, so approaches have been proposed to facilitate this. usually, these approaches cannot automatically identify change rules for one-replaced-by-many and many-replaced-by-one methods, and they trade off recall for higher precision using one or more experimentally-evaluated thresholds. we introduce aura, a novel hybrid approach that combines call dependency and text similarity analyses to overcome these limitations. we implement it in a java system and compare it on five frameworks with three previous approaches by dagenais and robillard, m. kim et al., and sch&auml;fer et al. the comparison shows that, on average, the recall of aura is 53.07% higher while its precision is similar, e.g., 0.10% lower.
engineering parallel applications with tunable architectures. current multicore computers differ in many hardware characteristics. software developers thus hand-tune their parallel programs for a specific platform to achieve the best performance; this is tedious and leads to non-portable code. although the software architecture also requires adaptation to achieve best performance, it is rarely modified because of the additional implementation effort. the tunable architectures approach proposed in this paper automates the architecture adaptation of parallel programs and uses an auto-tuner to find the best-performing software architecture for a particular machine. we introduce a new architecture description language based on parallel patterns and a framework to express architecture variants in a generic way. several case studies demonstrate significant performance improvements due to architecture tuning and show the applicability of our approach to industrial applications. software developers are exposed to less parallel programming complexity, thus making the approach attractive for experts as well as inexperienced parallel programmers.
identifying crosscutting concerns using historical code changes. detailed knowledge about implemented concerns in the source code is crucial for the cost-effective maintenance and successful evolution of large systems. concern mining techniques can automatically suggest sets of related code fragments that likely contribute to the implementation of a concern. however, developers must then spend considerable time understanding and expanding these concern seeds to obtain the full concern implementation. we propose a new mining technique (commit) that reduces this manual effort. commit addresses three major shortcomings of current concern mining techniques: 1) their inability to merge seeds with small variations, 2) their tendency to ignore important facets of concerns, and 3) their lack of information about the relations between seeds. a comparative case study on two large open source c systems (post-gresql and netbsd) shows that commit recovers up to 87.5% more unique concerns than two leading concern mining techniques, and that the three techniques complement each other.
an exploratory study of fault-proneness in evolving aspect-oriented programs. this paper presents the results of an exploratory study on the fault-proneness of aspect-oriented programs. we analysed the faults collected from three evolving aspect-oriented systems, all from different application domains. the analysis develops from two different angles. firstly, we measured the impact of the obliviousness property on the fault-proneness of the evaluated systems. the results show that 40% of reported faults were due to the lack of awareness among base code and aspects. the second analysis regarded the fault-proneness of the main aspect-oriented programming (aop) mechanisms, namely pointcuts, advices and intertype declarations. the results indicate that these mechanisms present similar fault-proneness when we consider both the overall system and concern-specific implementations. our findings are reinforced by means of statistical tests. in general, this result contradicts the common intuition stating that the use of pointcut languages is the main source of faults in aop.
a hot --- human, organizational and technological --- framework for a software engineering course. in this paper, we present a hot --- human, organizational and technological --- framework for software engineering and describe its application in a full one-semester software engineering course on agile software development. we suggest and illustrate how this framework has the potential to widen and deepen the students' understanding of software engineering processes.
quality of service profiling. many computations exhibit a trade off between execution time and quality of service. a video encoder, for example, can often encode frames more quickly if it is given the freedom to produce slightly lower quality video. a developer attempting to optimize such computations must navigate a complex trade-off space to find optimizations that appropriately balance quality of service and performance. we present a new quality of service profiler that is designed to help developers identify promising optimization opportunities in such computations. in contrast to standard profilers, which simply identify time-consuming parts of the computation, a quality of service profiler is designed to identify subcomputations that can be replaced with new (and potentially less accurate) subcomputations that deliver significantly increased performance in return for acceptably small quality of service losses. our quality of service profiler uses loop perforation (which transforms loops to perform fewer iterations than the original loop) to obtain implementations that occupy different points in the performance/quality of service trade-off space. the rationale is that optimizable computations often contain loops that perform extra iterations, and that removing iterations, then observing the resulting effect on the quality of service, is an effective way to identify such optimizable subcomputations. our experimental results from applying our implemented quality of service profiler to a challenging set of benchmark applications show that it can enable developers to identify promising optimization opportunities and deliver successful optimizations that substantially increase the performance with only small quality of service losses.
awareness 2.0: staying aware of projects, developers and tasks using dashboards and feeds. software development teams need to maintain awareness of various different aspects ranging from overall project status and process bottlenecks to current tasks and incoming artifacts. currently, there is a lack of theoretical foundations to guide tool selection and tool design to best support awareness tasks. in this paper, we explore how the combination of highly configurable project, team and contributor dashboards along with individual event feeds is used to accomplish extensive awareness. our results stem from an empirical study of several large development teams, with a detailed study of a team of 150 developers and additional data from another four project teams. we present how dashboards become pivotal to task prioritization in critical project phases and how they stir competition while feeds are used for short term planning. our findings indicate that the distinction between high-level and low-level awareness is often unclear and that integrated tooling could improve development practices.
moving into a new software project landscape. when developers join a software development project, they find themselves in a project landscape, and they must become familiar with the various landscape features. to better understand the nature of project landscapes and the integration process, with a view to improving the experience of both newcomers and the people responsible for orienting them, we performed a grounded theory study with 18 newcomers across 18 projects. we identified the main features that characterize a project landscape, together with key orientation aids and obstacles, and we theorize that there are three primary factors that impact the integration experience of newcomers: early experimentation, internalizing structures and cultures, and progress validation.
recurring bug fixes in object-oriented programs. previous research confirms the existence of recurring bug fixes in software systems. analyzing such fixes manually, we found that a large percentage of them occurs in code peers, the classes/methods having the similar roles in the systems, such as providing similar functions and/or participating in similar object interactions. based on graph-based representation of object usages, we have developed several techniques to identify code peers, recognize recurring bug fixes, and recommend changes for code units from the bug fixes of their peers. the empirical evaluation on several open-source projects shows that our prototype, fixwizard, is able to identify recurring bug fixes and provide fixing recommendations with acceptable accuracy.
falcon: fault localization in concurrent programs. concurrency fault are difficult to find because they usually occur under specific thread interleavings. fault-detection tools in this area find data-access patterns among thread interleavings, but they report benign patterns as well as actual faulty patterns. traditional fault-localization techniques have been successful in identifying faults in sequential, deterministic programs, but they cannot detect faulty data-access patterns among threads. this paper presents a new dynamic fault-localization technique that can pinpoint faulty data-access patterns in multi-threaded concurrent programs. the technique monitors memory-access sequences among threads, detects data-access patterns associated with a program's pass/fail results, and reports dataaccess patterns with suspiciousness scores. the paper also presents the description of a prototype implementation of the technique in java, and the results of an empirical study we performed with the prototype on several java benchmarks. the empirical study shows that the technique can effectively and efficiently localize the faults for our subjects.
towards contextualised software engineering education: an african perspective. the discipline of software engineering is continuously adapting to new challenges while gaining more and more insights. the age of globalisation has brought about a new movement of internationalisation and localisation. while practitioners fully embrace the efforts, educators only marginally consider the implications for the teaching and learning of software engineering. while the relevance of the software deployment context has been widely recognised, the intrinsic values of the development context are less evident. besides western cultural indicators being omnipresent in software applications, they are deeply rooted in software engineering concepts and methods. standards and models have been established in the absence of possible deviations from other -- e.g. african -- contexts. educators and authors of common and internationally used textbooks present software engineering concepts and methods as universally valid. thus software engineering graduates all over the world continue to be ill-equipped for specific software development contexts. moreover the necessity to localise software engineering education is illustrated by our vast amount of challenges, experiences and best-practices of teaching software engineering in a sub-saharan country. in this paper, we introduce a generic framework leading towards a contextualised software engineering education (cse2).
stakenet: using social networks to analyse the stakeholders of large-scale software projects. many software projects fail because they overlook stakeholders or involve the wrong representatives of significant groups. unfortunately, existing methods in stakeholder analysis are likely to omit stakeholders, and consider all stakeholders as equally influential. to identify and prioritise stakeholders, we have developed stakenet, which consists of three main steps: identify stakeholders and ask them to recommend other stakeholders and stakeholder roles, build a social network whose nodes are stakeholders and links are recommendations, and prioritise stakeholders using a variety of social network measures. to evaluate stakenet, we conducted one of the first empirical studies of requirements stakeholders on a software project for a 30,000-user system. using the data collected from surveying and interviewing 68 stakeholders, we show that stakenet identifies stakeholders and their roles with high recall, and accurately prioritises them. stakenet uncovers a critical stakeholder role overlooked in the project, whose omission significantly impacted project success.
determin: inferring likely deterministic specifications of multithreaded programs. the trend towards multicore processors and graphic processing units is increasing the need for software that can take advantage of parallelism. writing correct parallel programs using threads, however, has proven to be quite challenging due to nondeterminism. the threads of a parallel application may be interleaved nondeterministically during execution, which can lead to nondeterministic results---some interleavings may produce the correct result while others may not. we have previously proposed an assertion framework for specifying that regions of a parallel program behave deterministically despite nondeterministic thread interleaving. the framework allows programmers to write assertions involving pairs of program states arising from different parallel schedules. we propose an algorithm to dynamically infer likely deterministic specifications for parallel programs given a set of inputs and schedules. we have implemented our specification inference algorithm for java and have applied it to a number of previously examined java benchmarks. we were able to automatically infer specifications largely equivalent to or stronger than our manual assertions from our previous work. we believe that the inference of deterministic specifications can aid in understanding and documenting the deterministic behavior of parallel programs. moreover, an unexpected deterministic specification can indicate to a programmer the presence of erroneous or unintended behavior.
liability in software engineering: overview of the lise approach and illustration on a case study. lise is a multidisciplinary project involving lawyers and computer scientists with the aim to put forward a set of methods and tools to (1) define software liability in a precise and unambiguous way and (2) establish such liability in case of incident. this paper provides an overview of the overall approach taken in the project based on a case study. the case study illustrates a situation where, in order to reduce legal uncertainties, the parties to a contract wish to include in the agreement specific clauses to define as precisely as possible the share of liabilities between them for the main types of failures of the system.
practical fault localization for dynamic web applications. we leverage combined concrete and symbolic execution and several fault-localization techniques to create a uniquely powerful tool for localizing faults in php applications. the tool automatically generates tests that expose failures, and then automatically localizes the faults responsible for those failures, thus overcoming the limitation of previous fault-localization techniques that a test suite be available upfront. the fault-localization techniques we employ combine variations on the tarantula algorithm with a technique based on maintaining a mapping between statements and the fragments of output they produce. we implemented these techniques in a tool called apollo, and evaluated them by localizing 75 randomly selected faults that were exposed by automatically generated tests in four php applications. our findings indicate that, using our best technique, 87.7% of the faults under consideration are localized to within 1% of all executed statements, which constitutes an almost five-fold improvement over the tarantula algorithm.