waashk/dblp huggingface dataset:
financially informed requirements prioritization. this tutorial introduces a financially responsible approach to requirements prioritization that enhances the value creating potential of a software development project. the approach, known as the incremental funding method (ifm), is described in the book "software by numbers: low-risk, high-return development" [2,3]. tutorial attendees will learn how to group requirements into "chunks" of revenue-generating functionality known as minimal marketable features (mmfs), and how to carefully sequence those mmfs in order to maximize the overall value of the project, reduce initial funding investments, and manipulate other project metrics such as the time needed for a project to reach break-even status. a gentle introduction to financial analysis will also equip participants to analyze and understand the impact of other requirements prioritization decisions upon the financial returns of a project. this process is applicable within any iterative development approach.
goal-centric traceability for managing non-functional requirements. this paper describes a goal centric approach for effectively maintaining critical system qualities such as security, performance, and usability throughout the lifetime of a software system. in goal centric traceability (gct) non-functional requirements and their interdependencies are modeled as softgoals in a softgoal interdependency graph (sig). a probabilistic network model is then used to dynamically retrieve links between classes affected by a functional change and elements within the sig. these links enable developers to identify potentially impacted goals; to analyze the level of impact on those goals; to make informed decisions concerning the implementation of the proposed change; and finally to develop appropriate risk mitigating strategies. this paper also reports experimental results for the link retrieval and illustrates the gct process through an example of a change applied to a road management system.
early aspects at icse: workshop in aspect-oriented requirements engineering and architecture design. this paper summarizes the workshop in aspect-oriented requirements engineering and architecture design.
formal specification and development of an ada compiler - a vdm case study. the vienna development method (vdm) has been employed by dansk datamatik center (ddc) on a large-scale, industrial ada compiler development project. vdm is a formal specification and development method in that it insists on the initial specifications and all design steps being expressed in a formal (mathematically based) notation. this paper gives an overview of how vdm was used in the various steps of the ddc ada project, and we guide the reader through the steps involved from the initial formal specification of ada down to the actually coded multipass compiler. finally we report on the quantitative and qualitative experiences we have gained, both as regards the technical suitability of vdm for the project and as regards the implications on software management and quality assurance.
locating causes of program failures. which is the defect that causes a software failure? by comparing the program states of a failing and a passing run, we can identify the state differences that cause the failure. however, these state differences can occur all over the program run. therefore, we focus in space on those variables and values that are relevant for the failure, and in time on those moments where cause transitions occur---moments where new relevant variables begin being failure causes: "initially, variable argc was 3; therefore, at shell_sort(), variable [2] was 0, and therefore, the program failed." in our evaluation, cause transitions locate the failure-inducing defect twice as well as the best methods known so far.
the right algorithm at the right time: comparing data flow analysis algorithms for finite state verification. finite state verification is emerging as an important technology for proving properties about software. in our experience, we have found that analysts have different expectations at different times. when an analyst is in an exploratory mode, initially formulating and verifying properties, analyses usually find inconsistencies because of flaws in the properties or in the software artifacts being analyzed. once an inconsistency is found, the analyst begins to operate in a fault finding mode, during which meaningful counter example traces are needed to help determine the cause of the inconsistency. eventually systems become relatively stable, but still require re-verification as evolution occurs. during such periods, the analyst is operating in a maintenance mode and would expect re-verification to usually report consistent results. although it could be that one algorithm suits all three of these modes of use, the hypothesis explored here is that each would be best served by an algorithm optimized for the expectations of the analyst.
computer-aided micro-analysis of programs. an approach is described whereby one may, with the help of a computer, perform micro-analyses of programs by constructing their time-formulas. time-formulas are symbolic formulas which express execution times as functions of variables representing the time needed to perform common, elementary operations (e.g., addition, assignment, subscripting, loop overhead). by binding the variables to numeric values corresponding to a specific machine, one can estimate program execution times without resorting to empirical tests. some programs which have been analyzed using the suggested approach are reviewed in this paper. these include strassen's matrix multiplication algorithm, deterministic parsers and a certain class of straight-line programs. the software tools which are desirable for performing the suggested type of analysis are also discussed. finally, the paper outlines some of the related research problems which are worth investigating.
constructing test suites for interaction testing. software system faults are often caused by unexpected interactions among components. yet the size of a test suite required to test all possible combinations of interactions can be prohibitive in even a moderately sized project. instead, we may use pairwise or t-way testing to provide a guarantee that all pairs or t-way combinations of components are tested together. this concept draws on methods used in statistical testing for manufacturing and has been extended to software system testing. a covering array, ca(n; t, k, v), is an n &times; k array on v symbols such that every n &times; t sub-array contains all ordered subsets from v symbols of size t at least once. the properties of these objects, however, do not necessarily satisfy real software testing needs. instead we examine a less studied object, the mixed level covering array and propose a new object, the variable strength covering array, which provides a more robust environment for software interaction testing. initial results are presented suggesting that heuristic search techniques are more effective than some of the known greedy methods for finding smaller sized test suites. we present a discussion of an integrated approach for finding covering arrays and discuss how application of these techniques can be used to construct variable strength arrays.
must there be so few? including women in cs. women's under-representation in academic computer science is described for the u.s. and internationally. conditions that contribute to this situation are indentified, and motivations for increasing women's participation in computer science are discussed. according to recent research in the u.s., effective interventions at the undergraduate level include: actively recruiting women encouraging women to persist, and mentoring for the purpose of overcoming under-representation. the latter two practices are easily implemented.
from research to reward: challenges in technology transfer. over a five year period the applied science & technology group of ibm's hursley laboratory in england turned itself from a fully-funded research organisation into an entirely self-funded technology transfer group. much practical experience and insight was gained into the questions of: what are the obstacles to overcome in successful technology transfer? how to find a match between technology and customer? how best to manage risk and expectation?to be successful a technology transfer group needs to be correctly positioned within its sponsoring organisation, use management processes that provide flexibility and control, and develop a sophisticated engagement model for working with its customers.
the rmt (recursive multi-threaded) tool: a computer aided software engineering tool for monitoring and predicting software development progress. a number of software life-cycles for object-oriented software development (fountain model, recursive/parallel model, mcgregor and sykes model, and chaos model life cycle) exist today. however, these existing life-cycles have little or no support for estimating and monitoring progress during the development of the software. the ability to measure progress during the development is significant because it allows both the managers and the developers to determine whether a project is on schedule or not. identifying that a project is behind schedule allows managers and developers to notify appropriate individuals of any scheduling and/or budgetary impacts at an early stage during the development and to determine appropriate course of action. this demonstration presents the recursive multi-threaded (rmt) software life-cycle and the implemented computer aided software engineering tool based on rmt. the rmt tool supports the monitoring of progress during development, addresses the specific needs of the developing object-oriented software, and attempts to resolve deficiencies found in many existing software lifecycles. what makes rmt unique from existing software life-cycles is its use of a "thread" for partitioning and organizing software development activities. threads support iteration and recursion, which are critical concepts for the development of the software.
usage-centered software engineering: an agile approach to integrating users, user interfaces, and usability into software engineering practice. usage-centered design is a systematic, model-driven approach to visual and interaction design with an established record of effectiveness in a wide variety of settings and areas of application. the tutorial introduces the models and methods of usage-centered design and explores the integration of usage-centered approaches into software engineering practice. agile approaches to modeling will be emphasized, with the focus on use cases, which are central to usage-centered design and serve as a common thread throughout an integrated usage-centered software engineering process.
measuring memory protection. a protection measure based on a simple model of a protection system is presented. the measure shows how closely a computer system adheres to the principle of minimum privilege. its application to the operating system of the cambridge university cap computer is described and ways of bringing the operating system closer to a state of minimum privilege are discussed. the results of this work have demonstrated that the measure provides a useful tool for the designers of operating systems and other software. a module in a computer system has a repertoire of services it can perform; the services provided by a module are made available to other modules as functions. an original feature of the work described in this paper is the attention paid to functions in the context of protection in computer systems. the protection model and the protection measure are defined in terms of the objects accessible to a process and it is important to note that functions are considered to be objects.
highly reliable upgrading of components. after a system is deployed, fixes, enhancements, and modifications all occur that change the components that make up the system. unfortunately, new versions of components can introduce new errors and break existing, depended-upon behavior. when this happens, the old component version could have provided the correct behavior, but it is no longer part of the system. we propose a framework, hercules, for upgrading system components that, instead of removing the old version of the component, keeps multiple versions of a component running. doing so allows behavior to be utilized from all versions, and maintains system integrity and correctness even in the presence of newly introduced errors. this framework ensures that the move towards dynamic, configurable software systems does not lessen, but rather provides capabilities to enhance the reliability that software will achieve through the next century.
icse workshop on dynamic analysis (woda 2003). dynamic analysis of software systems has long proven to be a practical approach to gain understanding of the operational behavior of the system. this workshop will bring together researchers in the field of dynamic analysis to discuss the breadth off the field, order the field along logical dimensions, expose common issues and approaches, and stimulate synergistic collaborations among the participants.
safe query objects: statically typed objects as remotely executable queries. developers of data-intensive applications are increasingly using persistence frameworks such as ejb, hibernate and jdo to access relational data. these frameworks support both transparent persistence for individual objects and explicit queries to efficiently search large collections of objects. while transparent persistence is statically typed, explicit queries do not support static checking of types or syntax because queries are manipulated as strings and interpreted at runtime. this paper presents safe query objects, a technique for representing queries as statically typed objects while still supporting remote execution by a database server. safe query objects use object-relational mapping and reflective metaprogramming to translate query classes into traditional database queries. the model supports complex queries with joins, parameters, existentials, and dynamic criteria. a prototype implementation for jdo provides a type-safe interface to the full query functionality in the jdo 1.0 standard.
adaptive testing. the primary vehicle for demonstrating the performance of ballistic missile defense (bmd) software is testing in a simulated environment. the complexity of bmd software logic and the large volumes of input data preclude exhaustive testing. the problem is compounded by limitations on testing time, complicated test procedures, and lack of systematic procedures for performance analysis. this paper describes an approach towards providing an effective means for identifying the boundary of performance of bmd software. the approach, called adaptive testing, uses performance data to systematically redefine input data that will produce some specified level of system performance. components of the adaptive testing technology include an interactive scenario generator, a performance evaluator, an adaptive algorithm for test case perturbation, and a system, environment, and threat simulator (sets). problems associated with the approach are discussed as well as the expected payoff.
multiple mass-market applications as components. truly successful models for component-based software development continue to prove elusive. one of the few is the use of operating system, database and similar programs in many systems. we address three related problems in this paper. first, we lack needed models. second, we do not know the conditions under which such models can succeed. in particular, it is unclear whether the notable success with operating systems can be replicated. third, we do not know whether certain specific models can succeed. we are addressing these problems by evaluating a particular model that shares important characteristics with the successful operating system example: using compatible pc packages as components. our approach to evaluating such a model is to engage in a case study that aims to build an industrially successful system representative of an important class of systems. we report on our use of the model to develop a computational tool for reliability engineering. we draw two conclusions. first, this kind of model has the potential to succeed. second, even today, the model can produce significant returns, but it clearly carries considerable risks.
galileo: a tool built from mass-market applications. we present galileo, an innovative engineering modeling and analysis tool built using an approach we call package-oriented programming (pop). galileo represents an ongoing evaluation of the pop approach, where multiple large, architecturally coherent components are tightly integrated in an overall software system. galileo utilizes microsoft word, internet explorer, and visio to provide a low cost, richly functional fault tree modeling superstructure. based on the success of previous prototypes of the tool, we are now building a version for industrial use under an agreement with nasa langley research center.
sound methods and effective tools for engineering modeling and analysis. modeling and analysis is indispensable in engineering. to be safe and effective, a modeling method requires a language with a validated semantics; feature-rich, easy-to-use, dependable tools; and low engineering costs. today we lack adequate means to develop such methods. we present a partial solution combining two techniques: formal methods for language design, and package-oriented programming for function and usability at low cost. we have evaluated the approach in an end-to-end experiment. we deployed an existing reliability method to nasa in a package-oriented tool and surveyed engineers to assess its usability. we formally specified, improved, and validated the language. to assess cost, we built a package-based tool for the new language. our data show that the approach can enable costeffective deployment of sound methods by effective tools.
bandera: extracting finite-state models from java source code. finite-state verification techniques, such as model checking, have shown promise as a cost-effective means for finding defects in hardware designs. to date, the application of these techniques to software has been hindered by several obstacles. chief among these is the problem of constructing a finite-state model that approximates the executable behavior of the software system of interest. current best-practice involves hand-construction of models which is expensive (prohibitive for all but the smallest systems), prone to errors (which can result in misleading verification results), and difficult to optimize (which is necessary to combat the exponential complexity of verification algorithms).in this paper, we describe an integrated collection of program analysis and transformation components, called bandera, that enables the automatic extraction of safe, compact finite-state models from program source code. bandera takes as input java source code and generates a program model in the input language of one of several existing verification tools; bandera also maps verifier outputs back to the original source code. we discuss the major components of bandera and give an overview of how it can be used to model check correctness properties of java programs.
bandera: a source-level interface for model checking java programs. despite emerging tool support for assertion-checking and testing of object-oriented programs, providing convincing evidence of program correctness remains a difficult challenge. this is especially true for multi-threaded programs. techniques for reasoning about finite-state systems have been developing rapidly over the past decade and have the potential to form the basis of powerful software validation theologies.we have developed the bandera toolset [1] to harness the power of existing model checking tools to apply them to reason about correctness requirements of java programs. bandera provides tool support for defining and managing collections of requirements for a program, for extracting compact finite-state models of the program to enable tractable analysis, and for displaying analysis results to the user through a debugger-like interface. this paper describes and illustrates the use of bandera's source-level user interface for model checking java programs.
transformations of software models into performance models. it is widely recognized that in order to make performance validation an integrated activity along the software lifecycle it is crucial to be supported from automated approaches. easiness to annotate software models with performance parameters (e.g. the operational profile) and automated translations of the annotated models into "ready-to-validate" models are the key challenges in this direction. several methodologies have been introduced in the last few years to address these challenges. the tutorial introduces the attendance to the main methodologies for annotating and transforming software models into performance models.
towards aspect weaving applications. software must be adapted to accommodate new features in the context of changing requirements. in this paper, we illustrate how applications with aspect weaving capabilities can be easily and dynamically adapted with unforseen features. aspects were used at three levels: in the context of semantic analysers, within a bpel engine that orchestrates web services, and finally within bpel processes themselves. each level uses its own tailored domain-specific aspect language that is easier to manipulate than a general-purpose one (close to the programming language) and the pointcuts are independent from the implementation.
documentation for safety critical software. the authors review some of the fundamental difficulties presented by the design and the validation of software for safety critical applications. they suggest that software formal documentation techniques ameliorate the problems described. the principles behind a method of documenting both requirements and software design are presented. the methods have been used by the atomic energy control board of canada in its safety assessment of the shutdown software of the darlington generating station (d.l. parnas et al., 1991). the method is illustrated by applying it to a small portion of the safety feature actuation system of a pwr nuclear reactor
1st international workshop on advances and applications of problem frames. software problems originate from real worldproblems. a software solution must address its real worldproblem in a satisfactory way. a software engineer musttherefore understand the real world problem that theirsoftware intends to address. to be able to do this, thesoftware engineer must understand the problem contextand how it is to be affected by the proposed software,expressed as the requirements. without this knowledge theengineer can only hope to chance upon the right solutionfor the right problem. application of the problem framesapproach may well be a way of meeting this need.
tool support for formal methods. the author discusses the state of the art of formal methods tool support. the focus is on a particular tool: the eves verification system. eves is a new formal methods tool that integrates techniques from, among others, language design, language semantics, and logic and automated deduction. eves demonstrates a number of the features that can be found in the state-of-the-art formal methods tool. the author gives brief introductions to various other formal methods tools (e.g., hol, ehdm, the boyer-moore theorem prover) and discusses how these tools are being applied
m-eves: a tool for verifying software. this paper describes the development of a new tool for formally verifying software. the tool is called m-eves and consists of a new language, called m-verdi, for implementing and specifying software; a new logic, which has been proven sound; and a new theorem prover, called m-never, which integrates many state-of-the-art techniques drawn from the theorem proving literature. two simple examples are used to present the fundamental ideas embodied within the system.