waashk/dblp huggingface dataset:
dynamically discovering likely program invariants to support program evolution. explicitly stated program invariants can help programmers by identifying program properties that must be preserved when modifying code. in practice, however, these invariants are usually implicit. an alternative to expecting programmers to fully annotate code with invariants is to automatically infer likely invariants from the program itself. this research focuses on dynamic techniques for discovering invariants from execution traces. this article reports three results. first, it describes techniques for dynamically discovering invariants, along with an implementation, named daikon, that embodies these techniques. second, it reports on the application of daikon to two sets of target programs. in programs from gries's work on program derivation, the system rediscovered predefined invariants. in a c program lacking explicit invariants, the system discovered invariants that assisted a software evolution task. these experiments demonstrate that, at least for small programs, invariant inference is both accurate and useful. third, it analyzes scalability issues, such as invariant detection runtime and accuracy, as functions of test suites and program points instrumented.
automatic generation and maintenance of correct spreadsheets. existing spreadsheet systems allow users to change cells arbitrarily, which is a major source of spreadsheet errors. we propose a system that prevents errors in spreadsheets by restricting spreadsheet updates to only those that are logically and technically correct. the system is based on the concept of templates that describe the principal structure of the initial spreadsheet and all of its future versions. we have developed a program generator that translates a template into an initial spreadsheet together with customized update operations for changing cells and inserting/deleting rows and columns for this particular template.we have designed a type system for templates that ensures the following form of "spreadsheet maintenance safety": update operations that are generated from a type-correct template are proved to transform the spreadsheet only according to the template and to never produce any omission, reference, or type errors.finally, we have developed a prototype as an extension to excel, which has been shown by a preliminary usability study to be well accepted by end users.
verification support for workflow design with uml activity graphs. we describe a tool that supports verification of workflow models specified in uml activity graphs. the tool translates an activity graph into an input format for a model checker according to a semantics we published earlier. with the model checker arbitrary propositional requirements can be checked against the input model. if a requirement fails to hold an error trace is returned by the model checker. the tool automatically translates such an error trace into an activity graph trace by high-lighting a corresponding path in the activity graph. one of the problems that is dealt with is that model checkers require a finite state space whereas workflow models in general have an infinite state space. another problem is that strong fairness is necessary to obtain realistic results. only model checkers that use a special model checking algorithm for strong fairness are suitable for verifying workflow models. we analyse the structure of the state space. we illustrate our approach with some example verifications.
impact of the research community for the field of software configuration management. software configuration management (scm) is an important discipline in professional software development and maintenance. the importance of scm has increased as programs have become larger, more complex, and more mission/life-critical.this paper presents a brief summary of a full report that discusses the evolution of scm technology from the early days of software development to present, and the specific impact university and industrial research has had along the way.
towards safe distributed application development. distributed application development is overly tedious, asthe dynamic composition of distributed components is hardto combine with static safety with respect to types (typesafety) and data (encapsulation). achieving such safetyusually goes through specific compilation to generate theglue between components, or making use of a single programminglanguage for all individual components with ahardwired abstraction for the distributed interaction.in this paper, we investigate general-purpose programminglanguage features for supporting third-party implementationsof programming abstractions for distributed interactionamong components. we report from our experiencesin developing a stock market application based ontype-based publish/subscribe (tps) implemented (1) as alibrary in standard java as well as with (2) a homegrownextension of the java language augmented with specificprimitives for tps, motivated by the lacks of former implementation.we then revisit the library approach, investigatingthe impact of genericity, reflective features, and thetype system, on the implementation of a satisfactory tpslibrary. we then discuss the impact of these features alsoon other distributed programming abstractions, and henceon the engineering of distributed applications in general,pointing out lacks of mainstream programming environmentssuch as java as well as .net.
using raddle to design distributed systems. we describe our linguistic tool, raddle, and its use in designing distributed systems. raddle coordinates concurrent processes with the n-party interaction, a new high-level communication primitive. another important feature of raddle is the team, which encapsulates communicating processes. we discuss our efforts towards developing a complete methodology for using raddle and briefly describe our software toolset.
second international workshop on dynamic analysis (woda 2004). dynamic analysis techniques reason over programexecutions and show promise in aiding the developmentof robust and reliable large-scale systems. it has becomeincreasingly clear that limitations of static analysis can beovercome by integrating static and dynamic analyses, andthat the performance and value of dynamic analysis canbe improved by static analysis. hence, a key focus of theworkshop will be on hybrid analyses that involve bothstatic and dynamic components.
inculcating invariants in introductory courses. one goal of introductory software engineering courses is to motivate and instill good software engineering habits. unfortunately, practical constraints on typical courses often lead to student experiences that are antithetical to that goal: instead of working in large teams and dealing with changing requirements and maintaining programs over many years, courses generally involve students working alone or in small teams with short projects that end the first time the program works correctly on some selected input. small projects tend to reinforce poor software engineering practices. since the programs are small enough to manage cognitively in ad hoc ways, effort spent more precisely documenting assumptions seems wasteful. it is infeasible to carry out full industrial software development within the context of a typical university course. however, it is possible to simulate some aspects of safety critical software engineering in an introductory software engineering course. this paper describes an approach that focuses on thinking about and precisely documenting invariants, and checking invariants using lightweight analysis tools. we describe how assignments were designed to emphasize the importance of invariants and to incorporate program analysis tools with typical software engineering material and report on results from an experiment measuring students understanding of program invariants.
power: a tool for quantitative evaluation of software project effectiveness. in this paper a tool for quantitative method of evaluating software projects is presented. this method constitutes the project observation workbench and evaluation reportor (power). a representative project evaluation with power is presented to demonstrate its application.
how to design a system in which modules can be changed on the fly. in a system made up of many modules, each managing its own peculiar types of data structures, it is often necessary to update one of the modules so as to provide new features or an improvement in the internal organization. if the interface to the module is unchanged or merely augmented the programs which interact with the module need not be changed. if the system can be brought to an orderly halt and if the module does not manage permanent data structures, it will merely be necessary to recompile the modified module, relink the system, stop the old system, and install the new one. if the module does manage permanent data structures which must be modified and the system is one which is expected to continue operation throughout the change, the problem is more difficult, but it can be solved. this paper discusses a solution.
design and test of distributed applications. it is well known that programming and testing distributed systems can be extremely difficult. reasons for this include non-deterministic behavior, non-reproducibility of events, complex timing of events, and complex states. this paper presents a paradigm and system that will support a programmer when designing, programming, and testing a distributed application. our main point is that the structure introduced by the paradigm must be kept and exploited during design, programming, and testing. one is not helped by a programming method which introduces a structure just to break it down again. we have developed a structural model based on common structures in distributed systems. this structural model is used to describe the logical relationships between components in a system. it is also integrated into the programming environment.
why can't they create architecture models like "developer x"? an experience report. a large financial company, struggling with legacy systems that did not interoperate, performed a pilot project to teach software architecture to an enthusiastic application development team. experienced mentors, including the author, worked with the application team for seven months to complete their engineering goal successfully. however, the mentors were unsuccessful in their attempt to train any of the six members of the application team to create architecture models on their own, though they were able to create them collaboratively with the mentors. this surprising result is due to the application team's strong preference for concrete artifacts over abstract ones. even more surprising, an application developer from a different project, "developer x", read the architecture modeling documentation on an internal website and, without mentoring, created architecture models within a few days. in light of this failure to teach software architecture, two short-term strategies are suggested for the use of software architecture in companies.
achieving industrial relevance with academic excellence: lessons from the oregon master of software engineering. many educational institutions are developing graduate programs in software engineering targeted to working professionals. these educators face the dilemma of providing programs with both industrial relevance and academic excellence. this paper describes our experience and lessons learned in developing such a program, the oregon master of software engineering (omse). it describes a structured approach to curriculum design, curriculum design principles and methods that can be applied to develop a quality professional program.
icse 2003 workshop on software engineering for high assurance systems: synergies between process, product, and profiling (sehas 2003). a critical issue in software engineering is how to construct high assurance software systems, i.e., software systems where compelling evidence is required that the system delivers its services in a manner satisfying critical properties, such as safety and security. this two-day icse workshop, the third in a series of workshops on high assurance systems, will provide a forum for researchers and practitioners to exchange ideas and experiences relevant to the development of software for aerospace systems, medical systems, systems controlling nuclear power plants, and other critical systems. participants of the sehas 2003 workshop will explore the opportunities for, and benefits of, synergies between three important themes---product, process, and profiling---each theme reflecting an important aspect of software development for high assurance systems.
an incremental programming environment. this document describes an incremental programming environment (ipe) based on compilation technology, but providing facilities traditionally found only in interpretive systems. ipe provides a comfortable environment for a single programmer working on a single program. in ipe the programmer has a uniform view of the program in terms of the programming language. the program is manipulated through a syntax-directed editor and its execution is controlled by a debugging facility, which is integrated with the editor. other tools of the traditional tools cycle (translator, linker, loader) are applied automatically and are not visible to the programmer. the only interface to the programmer is the user interface of the editor.
adaptive feedback scheduling of incremental and design-to-time tasks. this paper discusses an approach for adaptive feedback scheduling in resource insufficient environments. in particular, we examine the problem of maximizing the utilization of the cpu for a collection of periodic incremental and design-to-time tasks with variations in actual execution times. cpu allocation beyond a minimum is performed according to a quality-of-service (qos) based utility function. schedulability analysis results are utilized to determine guaranteed execution time limits (worst-case schedulability boundary). past history based on actual task execution times is used to identify the actual schedulability boundary and execution time allocations are adjusted accordingly. this feedback control approach to scheduling supports opportunistic resource allocation beyond the analytic limits, while minimizing deadline misses and limiting them to optional execution increments.
transforming and extending the enterprise through it. in this time of economic turmoil, it is emerging as a foundation for transition to the new economy. this presentation provides a high-level perspective on the key business and technology megatrends shaping the future of it, as well as the key management initiatives required to harness and exploit it effectively. key issues include:&bull; what are the key trends and events that will drive new it investments during the next five years?&bull; how will technology advances and changes impact it deployment decisions?&bull; how can organizations harness and exploit it despite ever-increasing complexity and volatility?
validating real-time systems by history-checking trio specifications. we emphasize the importance of formal executable specifications in the development of real-time systems, as a means to assess the adequacy of the requirements before a costly development process takes place. trio is a first-order temporal logic language for executable specification of real-time systems that deals with time in a quantitative way by providing a metric to indicate distance in time between events and length of time intervals. we summarize the language and its model-parametric semantics. then we present an algorithm to perform history checking, i.e., to check that a history of the system satisfies the specification. this algorithm can be used as a basis for an effective specification testing tool. the algorithm is described; an estimation of its complexity is provided; and the main functionalities of the tool are presented, together with sample test cases. finally, we draw conclusions and indicate directions of future research.
new languages from old: the extension of programming languages by embedding, with a case study. embedding is the extension of a programming language without altering the processor for that language, and preferably using only the facilities of that language. while a single subroutine is the simplest form of semantic extension by embedding, embedding can produce powerful application-oriented languages (aol) in a relatively economical fashion. a first approximation to a design discipline for writing embedded aols is presented. snobol4 is discussed as a particularly receptive host language, in that it has flexible subroutine, data-structure, and storage allocation facilities, has a run-time compiler which can be called from a snobol4 program, and is widely available for almost all research computer systems. a description is given of automat, a snobol4-embedded aol for classroom or research experiments with abstract sequential machines. the generalized transition table is introduced as a data structure in which finite-state machines (fsm), turing machines, pushdown automata, and the like can be represented as special cases. data structures for sets, partitions and covers, sparse matrices, and tapes are provided as well. the automat aol currently includes over 100 operators developed according to the proposed method. applications thus far include an extensive fsm utility system, universal simulators for fsm and other models, fsm minimization, and krohn-rhodes decomposition. performance statistics are presented.
1st workshop on open source software engineering. open source software (oss) has recently become the focus of considerable interest, yet there remains a need for rigorous analytical inquiry into the subject. this workshop seeks to articulate oss as an se paradigm and to address the requirements of oss in terms of methodology & process, tools & enabling technologies, and human resources & project management. format: round-table discussion. size: maximum 40 participants. position papers required. the workshop report will be published in a special issue of iee proceedings - software on open source software engineering, and workshop participants will be encouraged to submit full research papers based on their position papers for possible inclusion in the special issue.
the 3rd workshop on open source software engineering. building on the success of "making sense of the bazaar" and "meeting challenges and surviving success" --- the 1st and 2nd workshops on open source software engineering (icse 2001 and icse 2002) --- this workshop ("taking stock of the bazaar') brings together researchers and practitioners for the purpose of discussing the diverse array of techniques --- as well as supporting tools and social/organizational contexts --- which can be observed in the domain of open source software.
collaboration, conflict and control: the 4th workshop on open source software engineering. building on the success of the first three workshops inthe series, which were held at icse 2001 (toronto), icse2002 (orlando) and icse 2003 (portland), the 4thworkshop on open source software engineering,("collaboration, conflict and control") brings togetherresearchers and practitioners for the purpose ofdiscussing the platforms and tools, techniques andprocesses, and the organizational structures that are usedto support and sustain communication, collaboration andconflict resolution within and between open sourcesoftware communities.
open source application spaces: the 5th workshop on open source software engineering. the goal of the 5th workshop on open source software engineering is to bring together researchers and practitioners for the purpose of building a roadmap of the ways in which various computing application spaces have been impacted by open source software and also by open source development methods, tools and organizational structures.
making resource decisions for software projects. software metrics should support managerial decisionmaking in software projects. we explain how traditionalmetrics approaches, such as regression-based models forcost estimation fall short of this goal. instead, wedescribe a causal model (using a bayesian network)which incorporates empirical data, but allows it to beinterpreted and supplemented using expert judgement.we show how this causal model is used in a practicaldecision-support tool, allowing a project manager totrade-off the resources used against the outputs(delivered functionality, quality achieved) in a softwareproject. the model and toolset have evolved in a numberof collaborative projects and hence capture significantcommercial input. extensive validation trials are takingplace among partners on the ec funded projectmodist (this includes philips, israel aircraft industriesand qinetiq) and the feedback so far has been verygood. the estimates are sensible and the causalmodelling approach enables decision-makers to reasonin a way that is not possible with other projectmanagement and resource estimation tools. to ensurewide dissemination and validation a version of thetoolset with the full underlying model is being madeavailable for free to researchers.
an experiment in program restructuring for performance enhancement. an experiment intended to determine the influence of the input data on the performance improvements resulting from program restructuring is described. this influence is found to be non-significant for the particular program, memory policy, restructuring procedure and inputs considered in the experiment. it is speculated that such a conclusion is likely to have much more general validity.
some results from an empirical study of computer software. a study has been carried out to relate the maintenance performance of a collection of pl/i programs to measures that characterize control flow, data usage, and software science attributes of the programs. the programs are from two subsystems of a business data processing application. interesting relationships were found not only between the maintenance data and the measures but also among the measures themselves. this paper discusses some of the stronger of these relationships.
clinical requirements engineering. in this paper, i make a case for integration of requirements engineering (re) with clinical disciplines. to back my case, i look at two examples that employ a clinical re approach, first, that of introducing email into the life of a brain-injured individual, and second, introducing digital darkroom tools into my life. the former uses a brownfield approach by starting with an existing clinical process, cognitive rehabilitation, and then defining an re process that fits. the latter uses a greenfield approach that postulates a new clinical re process that focuses on the problems some of us have using digital darkroom tools.