waashk/dblp huggingface dataset:
tracking source locations. many programming tools require information to be associated with source locations. current tools do this in different ways with different degrees of effectiveness. this paper is an investigation into the various approaches to maintaining source locations. it is based on an experiment that attempts to track a variety of locations over the evolution of a source file. the results demonstrate that relatively simple techniques can be very effective.
testing pervasive software in the presence of context inconsistency resolution services. pervasive computing software adapts its behavior according to the changing contexts. nevertheless, contexts are often noisy. context inconsistency resolution provides a cleaner pervasive computing environment to context-aware applications. a faulty context-aware application may, however, mistakenly mix up inconsistent contexts and resolved ones, causing incorrect results. this paper studies how such faulty context-aware applications may be affected by these services. we model how programs should handle contexts that are continually checked and resolved by context inconsistency resolution, develop novel sets of data flow equations to analyze the potential impacts, and thus formulate a new family of test adequacy criteria for testing these applications. experimentation shows that our approach is promising.
a language for advanced protocol analysis in automotive networks. the increased use and interconnection of electronic components in automobiles has made communication behavior in automotive networks drastically more complex. both communication designs at application level and complex communication scenarios are often under-specified or out of scope of existing analysis techniques. we extend traditional protocol analyzers in order to capture communication at the level of abstraction that reflects application design and show that the same technique can be used to specify, monitor and test complex scenarios. we present cfr (channel filter rule) models, a novel approach for the specification of analyzers and a domain-specific language that implements this approach. from cfr models, we can fully generate powerful analyzers that extract design intentions, abstract protocol layers and even complex scenarios from low level communication data. we show that three basic concepts (channels, filters and rules) are sufficient to build such powerful analyzers and identify possible areas of application.
calysto: scalable and precise extended static checking. automatically detecting bugs in programs has been a long-held goal in software engineering. many techniques exist, trading-off varying levels of automation, thoroughness of coverage of program behavior, precision of analysis, and scalability to large code bases. this paper presents the calysto static checker, which achieves an unprecedented combination of precision and scalability in a completely automatic extended static checker. calysto is interprocedurally path-sensitive, fully context-sensitive, and bit-accurate in modeling data operations --- comparable coverage and precision to very expensive formal analyses --- yet scales comparably to the leading, less precise, static-analysis-based tool for similar properties. using calysto, we have discovered dozens of bugs, completely automatically, in hundreds of thousands of lines of production, open-source applications, with a very low rate of false error reports. this paper presents the design decisions, algorithms, and optimizations behind calysto's performance.
analyzing model evolution. model-driven development leads to development processes in which a large number of different versions of models are produced. we present fame, a tool environment which enables fine-grained analysis of the version history of a model. the tool is generic in the sense that it can work with various model types including uml and domain-specific languages.
ahaa --agile, hybrid assessment method for automotive, safety critical smes. the need for software is increasingly growing in the automotive industry. software development projects are, however, often troubled by time and budget overruns, resulting in systems that do not fulfill customer requirements. both research and industry lack strategies to combine reducing the long software development lifecycles (as required by time-to-market demands) with increasing the quality of the software developed. software process improvement (spi) provides the first step in the move towards software quality, and assessments are a vital part of this process. unfortunately, software process assessments are often expensive and time consuming. additionally, they often provide companies with a long list of issues without providing realistic suggestions. the goal of this paper is to describe a new low-overhead assessment method that has been designed specifically for small-to-medium-sized (smes) organisations wishing to be automotive software suppliers. this assessment method integrates the structured-ness of the plan-driven spi models of capability maturity model integration (cmmi) and automotive spice with the flexibleness of agile practices.
rubacon: automated support for model-based compliance engineering. compliance frameworks, laws and regulations such as sarbanes oxley, basel ii, solvency ii, hipaa etc. demand from companies in a more and more rigorous way to demonstrate that their organisation, processes and supporting it landscape implement and follow a set of guidelines at differing levels of abstraction. the work presented in this paper aims to contribute to a software engineering process which is driven by security, risk and compliance management considerations. we concentrate on a part of this approach that focusses on the question how one can use software engineering methods and tools to enforce that the configuration of a system enforces the security policies that arise from business compliance regulations. we present tool support for model-based compliance engineering, i.e. for the model-based development and analysis of software configurations that ensures compliance with security policies. it allows one to check uml models of business applications and their configuration data for adherence to security policies and compliance requirements. the tool is based on standardized data formats, such as uml and xml, which makes its integration into existing business architectures as efficient as possible.
models for model's sake: why explicit system models are also an end to themselves. in automotive software and system design, explicit system and especially software models have only recently found their way into the development process. this paper will try to give an overview for what such models have so-far been used and which advantages they brought to vehicle manufacturers and suppliers. another focus of this paper is the comparison to functional models which are already used in the automotive industry to define control algorithms and function implementation. in many cases too strong analogies have been seen between the existing functional control algorithm models and the new system models - leading to suboptimal development processes and tools. this paper will therefore try to outline differences between these model types. finally, a synthesis between functional, system, and software models will be sketched.
an approach to detecting duplicate bug reports using natural language and execution information. an open source project typically maintains an open bug repository so that bug reports from all over the world can be gathered. when a new bug report is submitted to the repository, a person, called a triager, examines whether it is a duplicate of an existing bug report. if it is, the triager marks it as duplicate and the bug report is removed from consideration for further work. in the literature, there are approaches exploiting only natural language information to detect duplicate bug reports. in this paper we present a new approach that further involves execution information. in our approach, when a new bug report arrives, its natural language information and execution information are compared with those of the existing bug reports. then, a small number of existing bug reports are suggested to the triager as the most similar bug reports to the new bug report. finally, the triager examines the suggested bug reports to determine whether the new bug report duplicates an existing bug report. we calibrated our approach on a subset of the eclipse bug repository and evaluated our approach on a subset of the firefox bug repository. the experimental results show that our approach can detect 67%-93% of duplicate bug reports in the firefox bug repository, compared to 43%-72% using natural language information alone.
the influence of organizational structure on software quality: an empirical case study. often software systems are developed by organizations consisting of many teams of individuals working together. brooks states in the mythical man month book that product quality is strongly affected by organization structure. unfortunately there has been little empirical evidence to date to substantiate this assertion. in this paper we present a metric scheme to quantify organizational complexity, in relation to the product development process to identify if the metrics impact failure-proneness. in our case study, the organizational metrics when applied to data from windows vista were statistically significant predictors of failure-proneness. the precision and recall measures for identifying failure-prone binaries, using the organizational metrics, was significantly higher than using traditional metrics like churn, complexity, coverage, dependencies, and pre-release bug measures that have been used to date to predict failure-proneness. our results provide empirical evidence that the organizational metrics are related to, and are effective predictors of failure-proneness.
automatic generation of software behavioral models. dynamic analysis of software systems produces behavioral models that are useful for analysis, verification and testing. the main techniques for extracting models of functional behavior generate either models of constraints on data, usually in the form of boolean expressions, or models of interactions between components, usually in the form of finite state machines. both data and interaction models are useful for analyzing and verifying different aspects of software behavior, but none of them captures the complex interplay between data values and components interactions. thus related analysis and testing techniques can miss important information. in this paper, we focus on the generation of models of relations between data values and component interactions, and we present gk-tail, a technique to automatically generate extended finite state machines (efsms) from interaction traces. efsms model the interplay between data values and component interactions by annotating fsm edges with conditions on data values. we show that efsms include details that are not captured by either boolean expressions or (classic) fsm alone, and allow for more accurate analysis and verification than separate models, even if considered jointly.
a teamwork-based approach to programming fundamentals with scheme, smalltalk & java. in october 2004 the university of lugano in southern switzerland established a new faculty of informatics. its founding principles are innovation in teaching and faculty participation in the research community. with respect to teaching, students spend mornings attending lectures and afternoons in an atelier designed to support interaction both among students and with the instructors. in teaching the first year "programming fundamentals" courses, we took advantage of the clean slate nature of the faculty to introduce innovative teaching elements. the novel aspects include our use of scheme, smalltalk, and java, our combination of individual, pair and group projects and the integration of expert lectures to introduce useful, but slightly orthogonal elements at key points in the semester. our very positive experience is reported along with a discussion of aspects to improve in the future.
four enhancements to automateddistributed system experimentation methods. experimentation is an essential tool employed by the developers of software systems, especially distributed systems. in prior work we developed a model-driven framework for automating various experimentation tasks, such as workload generation, and demonstrated that it gives the engineer a cost-effective means to conduct large-scale experiments on distributed testbeds. we have enhanced the methods underlying the framework in four significant ways: (1) increasing the expressiveness of workloads by allowing for conditional and reactive behaviors; (2) supporting the repeatability of experiments through the creation of environment workloads that can control the operational context; (3) enabling the composability of application and environment workloads to obtain a broader class of experiments; and (4) extending the scope of experiment management to include control over multiple runs. we use the enhancements to conduct a series of interesting new experiments. specifically, the enhancements allow us to manipulate a fixed-wired testbed so that it simulates a mobile-wireless environment, and to selectively and maliciously inject faults into a system.
granularity in software product lines. building software product lines (spls) with features is a challenging task. many spl implementations support features with coarse granularity - e.g., the ability to add and wrap entire methods. however, fine-grained extensions, like adding a statement in the middle of a method, either require intricate workarounds or obfuscate the base code with annotations. though many spls can and have been implemented with the coarse granularity of existing approaches, fine-grained extensions are essential when extracting features from legacy applications. furthermore, also some existing spls could benefit from fine-grained extensions to reduce code replication or improve readability. in this paper, we analyze the effects of feature granularity in spls and present a tool, called colored ide (cide), that allows features to implement coarse-grained and fine-grained extensions in a concise way. in two case studies, we show how cide simplifies spl development compared to traditional approaches.
tool support for the navigation in graphical models. graphical models are omnipresent in the software engineering field, but most current graphical modeling languages do not scale with the increasing size and complexity of today's systems. the navigation in the diagrams becomes a major problem especially if different aspects of the system are scattered over multiple, only loosely coupled diagrams. in this paper we present the hierarchical navigation capabilities of the adora modeling tool. the user of this tool can freely control the level of detail in different parts of the model to reduce the size and complexity of the diagrams being displayed. our fisheye visualization technique makes it possible to integrate all modeling aspects (structure, data, behavior, etc.) in one coherent model while keeping the size and complexity of the diagrams within reasonable limits.
design patterns: between programming and software design. in computer science curricula the two areas programming and software engineering are usually separated. in programming students learn an object oriented language and then deepen their knowledge in other languages, algorithms and data structures. on the other hand software engineering starts with discussing processes and then addresses topics like requirements engineering, software design and software architectures. design patterns are on the border of these two areas and can be covered from both sides: either as an advanced programming course or as an application of software design and micro architectures. in this paper we present courses on design patterns and on software design which try to bridge this gap.
artoo: adaptive random testing for object-oriented software. intuition is often not a good guide to know which testing strategies will work best. there is no substitute for experimental analysis based on objective criteria: how many faults a strategy finds, and how fast. "random" testing is an example of an idea that intuitively seems simplistic or even dumb, but when assessed through such criteria can yield better results than seemingly smarter strategies. the efficiency of random testing is improved if the generated inputs are evenly spread across the input domain. this is the idea of adaptive random testing (art). art was initially proposed for numerical inputs, on which a notion of distance is immediately available. to extend the ideas to the testing of object-oriented software, we have developed a notion of distance between objects and a new testing strategy called artoo, which selects as inputs objects that have the highest average distance to those already used as test inputs. artoo has been implemented as part of a tool for automated testing of object-oriented software. we present the artoo concepts, their implementation, and a set of experimental results of its application. analysis of the results shows in particular that, compared to a directed random strategy, artoo reduces the number of tests generated until the first fault is found, in some cases by as much as two orders of magnitude. artoo also uncovers faults that the random strategy does not find in the time allotted, and its performance is more predictable.
predicting accurate and actionable static analysis warnings: an experimental approach. static analysis tools report software defects that may or may not be detected by other verification methods. two challenges complicating the adoption of these tools are spurious false positive warnings and legitimate warnings that are not acted on. this paper reports automated support to help address these challenges using logistic regression models that predict the foregoing types of warnings from signals in the warnings and implicated code. because examining many potential signaling factors in large software development settings can be expensive, we use a screening methodology to quickly discard factors with low predictive power and cost-effectively build predictive models. our empirical evaluation indicates that these models can achieve high accuracy in predicting accurate and actionable static analysis warnings, and suggests that the models are competitive with alternative models built without screening.
using the inverted classroom to teach software engineering. an inverted classroom is a teaching environment that mixes the use of technology with hands-on activities. in an inverted classroom, typical in-class lecture time is replaced with laboratory and in-class activities. outside class time, lectures are delivered over some other medium such as video on-demand. in a three credit hour course for instance, contact hours are spent having students actively engaged in learning activities. outside of class, students are focused on viewing 3-6 hours of lectures per week. additional time outside of class is spent completing learning activities. in this paper we present the inverted classroom model in the context of a software engineering curriculum. the paper motivates the use of the inverted classroom and suggests how different courses from the software engineering 2004 model curriculum volume can incorporate the use of the inverted classroom. in addition, we present the results of a pilot course that utilized the inverted classroom model at miami university and describe courses that are currently in process of piloting its use.
an empirical study of the effects of test-suite reduction on fault localization. fault-localization techniques that utilize information about all test cases in a test suite have been presented. these techniques use various approaches to identify the likely faulty part(s) of a program, based on information about the execution of the program with the test suite. researchers have begun to investigate the impact that the composition of the test suite has on the effectiveness of these fault-localization techniques. in this paper, we present the first experiment on one aspect of test-suite composition--test-suite reduction. our experiment studies the impact of the test-suite reduction on the effectiveness of fault-localization techniques. in our experiment, we apply 10 test-suite reduction strategies to test suites for eight subject programs. we then measure the differences between the effectiveness of four existing fault-localization techniques on the unreduced and reduced test suites. we also measure the reduction in test-suite size of the 10 test-suite reduction strategies. our experiment shows that fault-localization effectiveness varies depending on the test-suite reduction strategy used, and it demonstrates the trade-offs between test-suite reduction and fault-localization effectiveness.
formal verification of an automotive scenario in service-oriented computing. we report on the successful application of academic experience with formal modelling and verification techniques to an automotive scenario from the service-oriented computing domain. the aim of this industrial case study is to verify a priori, thus before implementation, certain design issues. the specific scenario is a simplified version of one of possible new services for car drivers to be provided by the in-vehicle computers.
genie: supporting the model driven development of reflective, component-based adaptive systems. engineering adaptive software is an increasingly complex task. here, we demonstrate genie, a tool that supports the modelling, generation, and operation of highly reconfigurable, component-based systems. we showcase how genie is used in two case-studies: i) the development and operation of an adaptive flood warning system, and ii) a service discovery application. in this context, adaptation is enabled by the gridkit reflective middleware platform.
ws-amuse - web service architecture for multimedia services. recently, a move from traditional, network specific multimedia services to ip-based solutions could be observed. although many of these applications have similar requirements and address the same issues, individual solutions based on specialized protocols are commonly used. this specialization prohibits the extraction and reuse of common services and hinders the interoperability between services and the integration with external components. a promising approach to overcome these disadvantages is the adoption of the service-oriented paradigm in communication protocols and a modularization into cooperating services. in this paper, we present a generic framework for multimedia applications consisting of a set of reusable web service components, a modeling language based on finite state automata and a compiler. the results of a bpel based prototypical implementation of a voice-over-ip application show that the service oriented approach and the automaton based modeling language can satisfy the above mentioned criteria and ease application development through a higher level of abstraction. on the other hand our benchmarks indicate that current web service technologies can lead to an insufficient performance, depending on the application scenario. possible solutions to circumvent these deficiencies are presented at the end of the paper.