waashk/dblp huggingface dataset:
adaptation hiding modularity for self-adaptive systems. growth in the complexity of computing systems, in the dynamism of the environments they operate in, and the need for timely adaptations as conditions change, now pose significant challenges for manual systems management and reconfiguration. there is thus increasing interest in systems that sense relevant conditions and adapt automatically as they change. a problem i have observed in designing such systems is that we lack principles and methods to guide their design. my thesis is that the modern notion of information hiding as a guide to modularization of software artifacts and design processes can be re-interpreted to provide a guide for organizing runtime structures and adaptation dynamics in self-adaptive systems. i argue that such an approach is important to achieving a number of key system properties, including scalability, analyzability, and efficiency. i plan to develop and evaluate my approach through a combination of case studies in a collaboration on self-adapting wireless sensor networks, by application to small, representative examples, and by arguments from first principles.
jpredictor: a predictive runtime analysis tool for java. jpredictor is a tool for detecting concurrency errors in java programs. the java program is instrumented to emit property-relevant events at runtime and then executed. the resulting execution trace is collected and analyzed by predictor, which extracts a causality relation sliced using static analysis and refined with lock-atomicity information. the resulting abstract model, a hybrid of a partial order and atomic blocks, is then exhaustively analyzed against the property and errors with counter-examples are reported to the user. thus, jpredictor can "predict" errors that did not happen in the observed execution, but which could have happened under a different thread scheduling. the analysis technique employed in jpredictor is fully automatic, generic (works for any trace property), sound (produces no false alarms) but it is incomplete may miss errors). two common types of errors are investigated in this paper: dataraces and atomicity violations. experiments show that jpredictor is precise (in its predictions), effective and efficient. after the code producing them was executed only once, jpredictor found all the errors reported by other tools. it also found errors missed by other tools, including static race detectors, as well as unknown errors in popular systems like tomcat and the apache ftp server.
adaptive probabilistic model for ranking code-based static analysis alerts. software engineers tend to repeat mistakes when developing software. automated static analysis tools can detect some of these mistakes early in the software process. however, these tools tend to generate a significant number of false positive alerts. due to the need for manual inspection of alerts, the high number of false positives may make an automated static analysis tool too costly to use. in this research, we propose to rank alerts generated from automated static analysis tools via an adaptive model that predicts the probability an alert is a true fault in a system. the model adapts based upon a history of the actions the software engineer has taken to either filter false positive alerts or fix true faults. we hypothesize that by providing this adaptive ranking, software engineers will be more likely to act upon highly ranked alerts until the probability that remaining alerts are true positives falls below a subjective threshold.
asam odx: syntax as semantics. in this paper, we outline a possible formalization of the semantics of the xml-based odx language. odx is a substantial part of the emerging automotive asam mcd standard, which describes a middleware layer between offboard diagnosis applications and onboard diagnosis services of electronic control units (ecus) of cars. the contribution of our work is threefold: firstly, a consequent application of our results can contribute to a well-structured development process in the automotive diagnosis domain. we are currently showing this in practice as part of our ongoing cooperation with the diagnosis department of audi ag. secondly, our proposition is the first step towards guaranteed standard-conformity of implementations of the mcd run-time system, also specified by the standard and strongly depending on odx and its semantics. last but not least, the paper can serve as an encouraging example of the application of formal methods in practice.
stakeholder value driven threat modeling for off the shelf based systems. as the trend of the usage of third party commercial-off-the-shelf (cots) and open source software continuously increases [2], cots security has become a major concern for many organizations whose daily business extensively relies upon a healthy it infrastructure. but, according to the 2006 csi/fbi computer criminal survey, 47% of the surveyed organizations only spent no more than 2% of the it budget in security. often, competing with limited it resources and the fast changing internet threats, the ability to prioritize security vulnerabilities and address them efficiently has become a critical success factor for every security manager.
predicting defects using network analysis on dependency graphs. in software development, resources for quality assurance are limited by time and by cost. in order to allocate resources effectively, managers need to rely on their experience backed by code complexity metrics. but often dependencies exist between various pieces of code over which managers may have little knowledge. these dependencies can be construed as a low level graph of the entire system. in this paper, we propose to use network analysis on these dependency graphs. this allows managers to identify central program units that are more likely to face defects. in our evaluation on windows server 2003, we found that the recall for models built from network measures is by 10% points higher than for models built from complexity metrics. in addition, network measures could identify 60% of the binaries that the windows developers considered as critical-twice as many as identified by complexity metrics.
modular-like transformations and style checking for crosscutting programming concepts. programmers resort to design patterns, micro-architectures, and other idioms when their design ideas can't be expressed directly in the programming language. the crosscutting code that appears as a result makes it harder to ensure a correct implementation of the idiom, and complicates software evolution when the idiom's implementation cannot be modularly substituted or extended like a method or class. we propose concepts, an ide-based mechanism for declaring, checking, and evolving crosscutting design idioms. programmers code their design idioms as before, but also declare their fundamental properties in supplemental files. a concept's behavior and implementation are described separately. this separation permits describing a new implementation for a concept and then having the concept tool mechanically transform the concept's current implementation into the new one. as a result we aim to get many of the same benefits for concepts that we get for classes: checking of key behaviors and substitutability.
a case study evaluation of maintainability and performance of persistency techniques. efforts for software evolution supersede any other part of the software life cycle. technological decisions have a major impact on the maintainability, but are not well reflected by existing code or architecture based metrics. the way the persistency of object structures with relational databases is solved affects the maintainability of the overall system. besides maintainability other quality attributes of the software are of interest, in particular performance metrics. however, a systematic evaluation of the benefits and drawback of different persistency frameworks is lacking. in this paper we systematically evaluate the maintainability and performance of different technological approaches for this mapping. the paper presents a testbed and an evaluation process with specifically designed metrics to evaluate persistency techniques regarding their maintainability and performance. in the second part we present and discuss the results of the case study.
assessing changeability by investigating the propagation of change types. we propose an approach to build a changeability assessment model for source code entities. based on this model, we will assess the changeability of evolving software systems. the changeability assessment is based on a taxonomy of more than 30 change types and a classifation of these in terms of change significance levels for consecutive versions of software entities. we consider change type propagation on different levels of granularity ranging from method changes to interface and class changes. we claim that this kind of assessment is effective in pointing to potential causes of maintainability problems in evolving software systems.
: factoring-aware inary daptation of evolving libraries. although in theory the apis of software libraries and frameworks should be stable, they change in practice. this forces clients of the library api to change as well, making software maintenance expensive. changing a client might not even be an option if its source code is missing or certain policies forbid its change. by giving a library both the old and the new api, clients can be shielded from api changes and can run with the new version of the library. this paper presents our solution and a tool, reba, that automatically generates compatibility layers between new library apis and old clients. in the first stage, reba generates another version of the library, called adapted-library, that supports both the old and the new apis. in the second stage, reba shrinks the adapted-library into a minimal, client-specific compatibility layer containing only classes truly required by the client. evaluations on controlled experiments and case studies using eclipse core libraries shows that our approach effectively adapts clients to new library versions, and is efficient.
using software model checking for software component certification. recently, the notion of a third-party certifier has emerged. the certifier ensures that the published properties of a component have indeed been verified. while software certification can benefit component buyers and developers, we believe that the lack of techniques and standards has hampered the spread of its use. this research seeks to accomplish two goals: to develop state-space search strategies that enable us to use software model checkers to certify programs and to decrease the amount of intellectual property that the developer is required to share for certification.
dysy: dynamic symbolic execution for invariant inference. dynamically discovering likely program invariants from concrete test executions has emerged as a highly promising software engineering technique. dynamic invariant inference has the advantage of succinctly summarizing both "expected" program inputs and the subset of program behaviors that is normal under those inputs. in this paper, we introduce a technique that can drastically increase the relevance of inferred invariants, or reduce the size of the test suite required to obtain good invariants. instead of falsifying invariants produced by pre-set patterns, we determine likely program invariants by combining the concrete execution of actual test cases with a simultaneous symbolic execution of the same tests. the symbolic execution produces abstract conditions over program variables that the concrete tests satisfy during their execution. in this way, we obtain the benefits of dynamic inference tools like daikon: the inferred invariants correspond to the observed program behaviors. at the same time, however, our inferred invariants are much more suited to the program at hand than daikon's hard-coded invariant patterns. the symbolic invariants are literally derived from the program text itself, with appropriate value substitutions as dictated by symbolic execution. we implemented our technique in the dysy tool, which utilizes a powerful symbolic execution and simplification engine. the results confirm the benefits of our approach. in daikon's prime example benchmark, we infer the majority of the interesting daikon invariants, while eliminating invariants that a human user is likely to consider irrelevant.
a quality-driven approach to enable decision-making in self-adaptive software. self-adaptive software is a closed-loop system aims at altering itself in response to changes at runtime. such a system, normally, requires monitoring, detecting (analyzing), deciding (planning), and acting (effecting) processes to fulfill adaptation requirements. this research mainly focuses on developing a quality-driven framework to facilitate realizing the deciding process. the framework is required to capture goals of adaptation, utility information, and domain characteristics in a knowledge-base.
an empirical study of software developers' management of dependencies and changes. different approaches and tools have been proposed to support change impact analysis, i.e., the identification of the potential consequences of a change, or the estimation of what needs to be modified to accomplish a change. however, just a few empirical studies of software developers' actual change impact analysis approaches have been reported in the literature. to minimize this gap, this paper describes an empirical study of two software development teams. it describes, through the presentation of ethnographic data, the strategies used by software developers to handle the effect of software dependencies and changes in their work. the concept of impact management is proposed as an analytical framework to present these practices and is used to suggest avenues for future research in change impact analysis techniques.
4th international workshop on mining software repositories (msr 2007). software repositories such as source control systems, defect tracking systems, and archived communications between project personnel are used to help manage the progress of software projects. software practitioners and researchers more and more recognize the potential benefit of mining this information to support the maintenance of software systems, improve software design/reuse, and empirically validate novel ideas and techniques. research is now proceeding to uncover the ways in which mining these repositories can help to understand software development, to support predictions about software development, and to plan various evolutionary aspects of software projects.
interval quality: relating customer-perceived quality to process quality. we investigate relationships among software quality measures commonly used to assess the value of a technology, and several aspects of customer perceived quality measured by interval quality (iq): a novel measure of the probability that a customer will observe a failure within a certain interval after software release. we integrate information from development and customer support systems to compare defect density measures and iq for six releases of a major telecommunications system. we find a surprising negative relationship between the traditional defect density and iq. the four years of use in several large telecommunication products demonstrates how a software organization can control customer perceived quality not just during development and verification, but also during deployment by changing the release rate strategy and by increasing the resources to correct field problems rapidly. such adaptive behavior can compensate for the variations in defect density between major and minor releases.
sharig and reusing architectural knowledge - architecture, rationale, and design intent. the shift of the software architecture community towards architectural knowledge has brought along some promising research directions. in this workshop we discuss the issues that lead to the application of architectural knowledge in research and industrial practice as well as presenting ongoing research and new ideas to advance the field. we expect to examine the state of the art and practice and gauge future challenges and trends. this year's workshop has a strong emphasis on documenting, sharing, and reusing architectural rationale and design intent.
automatic modularity conformance checking. according to parnas's information hiding principle and baldwin and clark's design rule theory, the key step to decomposing a system into modules is to determine the design rules (or in parnas's terms, interfaces) that decouple otherwise coupled design decisions and to hide decisions that are likely to change in independent modules. given a modular design, it is often difficult to determine whether and how its implementation realizes the designed modularity. manually comparing code with abstract design is tedious and error-prone. we present an automated approach to check the conformance of implemented modularity to designed modularity, using design structure matrices as a uniform representation for both. our experiments suggest that our approach has the potential to manifest the decoupling effects of design rules in code, and to detect modularity deviation caused by implementation faults. we also show that design and implementation models together provide a comprehensive view of modular structure that makes certain implicit dependencies within code explicit.
the 3rd international workshop on software engineering for secure systems sess07 - dependable and secure. the theme of this year of the international conference on software engineering is about "developing dependable software", acknowledging the fact that our lives depend directly on several complex software-based systems. the internet connects and enables a growing list of critical activities from which people expect services and revenues. they should be able to trust these systems to provide data and elaborations with a degree of confidentiality, integrity, and availability compatible with their needs. the pervasiveness of software products in the creation of critical infrastructures has raised the value of trustworthiness and new efforts should be dedicated to achieve it. yet, nowadays almost every application has some kind of security requirement even if its use is not to be considered critical.
modeling in software engineering. the software modeling community is primarily concerned with reducing the gap between problem and software implementation through the use of models that describe complex systems at multiple levels of abstraction and from a variety of perspectives. a model is an abstraction of some aspect of an existing or planned system. models are created to serve particular purposes, for example, to present a human-understandable description of some aspect of a system or to present information in a form that can be mechanically analyzed.
time will tell: fault localization using time spectra. we present an automatic fault localization technique which leverages time spectra as abstractions for program executions. time spectra have been traditionally used for performance debugging. by contrast, we use them for functional correctness debugging by identifying pieces of program code that take a "suspicious" amount of time to execute. the approach can be summarized as follows: time spectra are collected from passing and failing runs, observed behavior models are created using the time spectra collected from passing runs, and deviations from these models in failing runs are identified and scored as potential causes of failures. our empirical evaluations conducted on three real-life projects suggest that the proposed approach can effectively reduce the space of potential root causes for failures, which can in turn improve the turn around time for fixes.
3-step knowledge transition: a case study on architecture evaluation. software engineering is developing very fast. to keep up with the changes, software companies need effective methods of knowledge transfer. in the paper a 3-step approach to knowledge transfer, called technical drama, is presented. the paper is focused on transferring knowledge concerning architecture evaluation, but the approach could also be applied to transferring knowledge concerning inspections, testing etc. it is claimed in the paper that the technical drama can be useful in the industrial context (two case studies are described) as well as at university (then a kind of software studio is required).
early aspects at icse 2007: workshop on aspect-oriented requirements engineering and architecture design. the "early aspects @ icse'07" is the 11th workshop in the series of early aspects workshops [1] which focuses on aspect identification during the requirements engineering and architecture derivation activities. the specific aim of the present workshop is twofold: (a) to initiate creation of an early aspects application demonstration and comparisons benchmark; and (b) to solicit submission of new research.
evaluating dependability attributes of component-based specifications. component-based development (cbd) is established in many application domains. there is a strong trend in applying the same approach in different domains of dependable systems. however, a precondition of a successful use of cbd in these domains is the utilization of theories, methods and technologies to predict and evaluate dependability attributes. this tutorial gives an analysis of current methodologies of attribute-specific evaluation methods for dependable component-based systems. we identify limitations of the current technologies, discusses existing and possible new solutions to overcome these limitations both from a research-oriented and practical perspective.
juzi: a tool for repairing complex data structures. this paper describes juzi, a tool for automatic repair of complex data structures. juzi takes a java class representing the data structure as well as a predicate method that specifies the structural integrity constraints as inputs. juzi instruments its inputs and generates a new java class which behaves similarly to the original class, yet automatically repairs itself when the structural integrity constraints are violated. juzi implements a novel repair algorithm. given a structure that violates its integrity constraints, juzi performs a systematic search based on symbolic execution to repair the structure, i.e., mutate it such that the resulting structure satisfies the given constraints. experiments on structures ranging from library classes to standalone applications, show that juzi repairs complex structures while enabling programs to recover from erroneous executions caused by data structure corruptions.
metamodel-based tool integration with moflon. nowadays, a typical software development process involves many developers which participate in the development process by using a wide variety of development tools. as a consequence, the data representing the project as a whole is distributed over different development tools. for the purpose of consistency, maintainability, and traceability it is an essential task to be aware of the relationships between semantic equivalent data in different tool repositories. the real-time systems lab at the technische universität darmstadt performs research in the area of tool and metamodel integration to provide solutions to overcome this gap. in this demonstration we present the metamodeling framework moflon that addresses these issues by bringing together the latest omg standards with graph transformations and triple graph grammars. using moflon, developers can generate code for specific tools needed to perform analysis and transformation on one development tool or to incrementally integrate data of different modeling tools.