waashk/dblp huggingface dataset:
demonstration of agenda tool set for testing relational database applications. database systems play an important role in nearly every modern organization, yet relatively little research effort has focused on how to test them. agenda, a (test) generator for database applications, is a research prototype tool set for testing db application programs. in testing such applications, the states of the database before and after execution play an important role, along with the user's input and system output. agenda components populate the database, generate inputs, and check aspects of the correctness of output and new db state.
program refinement by transsformation. program maintenance is simplified when the program to be modified can be viewed as an abstract algorithm to which clearly documented implementation decisions have been applied to produce an efficient realization. the harvard program development system (pds) [8] is a programming support environment that encourages users to take this view of programs. a user of the pds creates transformations that incorporate implementation choices, and the system uses these transformations to refine concrete programs from their abstract counterparts. in addition to simplifying maintenance, this method supports the use of notational extensions and the development of program families. we describe the transformation facilities available to the user of the pds, and we discuss aspects of the implementation of these facilities.
a system for program refinement. the program development system (pds) is a programming environment, an integrated collection of interactive tools that support the process of program definition, testing, and maintenance. the pds is intended to aid the development of large programs, especially program families whose members must be maintained in synchrony. the system facilitates implementation by stepwise refinement, and it keeps a refinement history that allows program modifications made at a high level of abstraction to be reflected efficiently and automatically in the corresponding low level code. analysis tools are used both to support program validation and to guide program refinement. we describe the pds and the tools incorporated in it, and we conclude with an example of its use.
extending the implementation scheme of functional programming system fp for supporting the formal software development methodology. an extension to the implementation scheme of functional programming system fp is proposed for handling multiple order operations at function level. the concepts of functional form operator (ffo), nth order applications, and invariant semantics of functional forms are introduced. an ffo can be taken as either an operator at function level, or a variable of other operations for building new ffo's. thus variable-free operators can be defined for mappings from a list of functions to a new function denoted by a functional form, or from a list of ffo's to a new one. together with the notion of multi-order applications, a hierarchy of operations at function level can be handled. this approach is useful for supporting the formal software development methodology characterized by top-down functional specification, bottom-up function mapping construction and stepwise validation.
testtube: a system for selective regression testing. the paper describes a system called testtube that combines static and dynamic analysis to perform selective retesting of software systems written in c. testtube first identifies which functions, types, variables and macros are covered by each test unit in a test suite. each time the system under test is modified, testtube identifies which entities were changed to create the new version. using the coverage and change information, testtube selects only those test units that cover the changed entities for testing the new version. we have applied testtube to selective retesting of two software systems, an i/o library and a source code analyzer. additionally, we are adapting testtube for selective retesting of nondeterministic systems, where the main drawback is the unsuitability of dynamic analysis for identification of covered entities. our experience with testtube has been quite encouraging, with an observed reduction of 50% or more in the number of test cases needed to test typical software changes
use of cluster analysis to evaluate software engineering methodologies. the development of quantitative measures to evaluate software development techniques is necessary if we are going to develop appropriate methodologies for software production. data is collected by the software engineering laboratory at nasa goddard space flight center on developing medium scale projects of up to ten man years effort. in this study, cluster analysis was used on this collected data and several measures are proposed. these measurements are objective, quantifiable, are the results of the methodology, and most important, seem relevant.
software engineering for adaptive and self-managing systems. the objective of this workshop is to consolidate the interest in the software engineering community on autonomic, self-managing, self-healing, self-optimizing, self-configuring, and self-adaptive systems. the workshop will provide a forum for researchers to share new results, raise awareness of new adaptive concerns, and promote collaboration among the community. this workshop will be the first of several to assess progress and identify challenges in this important area.
an integrated method for effective behaviour analysis of distributed systems. behavioural analysis is a valuable aid for the design and maintenance of well-behaved distributed systems. dataflow and reachability analyses are two orthogonal, but complementary, behavioural analysis techniques. individually, each of these techniques may be inadequate for the analysis of large-scale distributed systems. on the one hand, dataflow analysis algorithms, while tractable, may not be sufficiently accurate to provide meaningful detection of errors. on the other hand, reachability analysis, while providing exhaustive analysis, may be computationally too expensive for complex systems. in this paper, we present a method which integrates dataflow and reachability analysis techniques to provide a flexible and effective means for analysing distributed systems at the preliminary and final design stages respectively. we also describe some effective measures taken to improve the adequacy of the individual analysis techniques using the concepts of action dependency and context constraints. a prototype supporting the method has been built, and its performance is described in this paper. a realistic example of a distributed track control system is used as a case study
checking subsystem safety properties in compositional reachability analysis. the software architecture of a distributed program can be represented by an hierarchical composition of subsystems, with interacting processes at the leaves of the hierarchy. compositional reachability analysis has been proposed as a promising automated method to derive the overall behavior of a distributed program in stages, based on its architecture. the method is particularly suitable for the analysis of programs which are subject to evolutionary change. when a program evolves, only behavior of those subsystems affected by the change need be re-evaluated. the method however has a limitation. the properties available for analysis are constrained by the set of actions that remain globally observable. the properties of subsystems, may not be analyzed. we extend the method to check safety properties of subsystems which may contain actions that are not globally observable. these safety properties can still be checked in the framework of compositional reachability analysis. the extension is supported by augmenting finite-state machines with a special undefined state /spl pi/. the state is used to capture possible violation of the safety properties specified by software developers. the concepts are illustrated using a gas station system as a case study.
a model for description of communication protocol. this paper presents a model for the description of communication protocol in view of the total behavior of terminal equipment. in this model, a protocol entity is modeled as a group of processes and monitors, and synchronization between input and output processes is represented by the synchronizing mechanism based on the concept of the monitor. furthermore, it is possible to specify the relation between entities of different layers of the protocol, including the relation between communication and local functions of terminal equipment. as an example of protocol description based on this model, teletex document layer protocol written in concurrent pascal language is illustrated.
verifying safety policies with size properties and alias controls. many software properties can be analysed through a relational size analysis on each function's inputs and outputs. such relational analysis (through a form of dependent typing) has been successfully applied to declarative programs, and to restricted imperative programs; but it has been elusive for object-based programs. the main challenge is that objects may mutate and they may be aliased. in this paper, we show how safety policies of programs can be analysed by tracking size properties of objects and be enforced by objects' invariants and the preconditions of methods. we propose several new ideas to allow both mutability and sharing of objects, whilst aiming for precision in our analysis. we introduce the concept of size-immutability to facilitate sharing, and also a set of alias controls to track unaliased objects whose size properties may change. we formalise our results through a set of advanced type checking rules for an object-based imperative language. we re-affirm the utility of the proposed type system by showing how a variety of software properties can be automatically verified according to size-inspired safety policies.
high-level specification of concurrency control in distributed database systems. concurrency control is one of the major issues in database systems; therefore, many concurrency control algorithms based on different strategies have been proposed. unfortunately there is still lack of a general model for describing these algorithms. hence, algorithms cannot be uniformly presented, which makes it hard to understand them and to prove their correctness. this paper proposes a high level specification, based on an object-oriented model, of concurrency control algorithms. concurrency control algorithms are specified in a high level fashion without losing their formality. basing on the object-oriented model, objects are individually specified. therefore, the specification of a concurrency control algorithm consists of the specifications of objects and their interactions.
diagnostic system for distributed software: a relational database approach. software errors in distributed systems are difficult to detect, locate and correct. the relational database approach in software diagnostics is an integrated approach encompassing most features in static analysis, dynamic testing, symbolic execution and performance evaluation techniques. modified syntax analysis of source program and testing run of the instrumented code generate the basis relations (symbol tables, graph models, program fragments, execution histories) from which diagnostic information is retrieved interactively. the basis relations contain necessary information to diagnose the software since data structures, algorithms and execution behavior of the software are included. implementations of some typical dynamic testing features extended to distributed software are discussed and illustrated.
software engineering for large-scale multi-agent systems - selmas'04. the development of multi-agent systems (mas) is nota trivial task. in addition, with the advances in internettechnologies, mas are undergoing a transition from closedto open architectures composed of a huge number of autonomousagents, which operate and move across differentenvironments. in fact, openness introduces additional complexityto the system modeling, design and implementation.it also impacts on most quality attributes of mas, includingscalability, interoperability, reliability and adaptability.this workshop brings together researchers and practitionersto discuss the current state and future direction of researchin software engineering for open mas. a particularinterest is to understand those issues in the agent technologythat make it difficult and/or improve the production oflarge open systems.
fifth workshop on software engineering for large-scale multi-agent systems (selmas). software is becoming present in every aspect of our lives, pushing us inevitably towards a world of ambient computing systems. multi-agent systems (mas) are a prominent technology which facilitates modeling and development of large-scale distributed systems. in recent years, software engineering research has focused on methodologies and techniques for improving mas design and implementation. however, making large mas dependable is still an open issue. the fifth workshop on software engineering for large-scale multi-agent systems (selmas 2006) aims to bring together academic, industrial and commercial communities interested in agent-oriented software engineering topics to discuss the different technologies being defined and used in the development of dependable mas.
a generalized assertion language. the motivation behind the work in debugging languages is to provide the programmer with primitives so that he may search for events during execution, which are suspected to be anomalous. events that may be specified by most existing debugging languages are very elementary. also, there are no facilities to combine them into more complex events. even though he can selectively monitor the history of execution, the programmer usually has to explore a vast mass of information in order to check the absence or presence of anomalous conditions. the philosophy of the assertion approach is to provide facilities with which the programmer may specify conditions, which the system can check at execution time. only violations are reported. by suppressing irrelevant information, it makes it a lot easier to detect anomalies. the assertion language described in this paper is generalized in the sense that it permits the programmer to refer to not only current events, but also past events. without such generalization, it is not possible to specify many interesting properties of programs. in addition, the language is open-ended by allowing a user to define checking routines of his own. relevant aspects of the language and examples are given.
non-intrusive object introspection in c++: architecture and application. we describe the design and implementation of system architecture to support object introspection in c++. in this system, information is collected by parsing class declarations, and used to build a supporting environment for object introspection. our approach is nonintrusive because it requires no change to the original class declarations and libraries, and it guarantees compatibility between objects before and after the addition of introspective capability. this is critical if one wants to integrate third-party class libraries, which are often supplied as black boxes and allow no modification, into highly dynamic applications. we show two applications: automatic i/o support for c++ objects; and an interactive exercise of dynamically loaded c++ class libraries
workshop description of 4th workshop on software quality (wosq). cost, schedule and quality are highly correlated factors in software development. they basically form three sides of the same triangle. beyond a certain point (the "quality is free" point), it is difficult to increase the quality without increasing either cost or schedule or both for the software under development. as products and applications mature, users expect higher quality products. they want it organizations to be responsible and accountable for the quality claims made by the product marketing teams. in the last couple decades, much software engineering research has focussed on standards, methodologies and techniques for improving software quality, measuring software quality and software quality assurance. most of this research is focused on the internal/development view of quality. more recent studies done in conjunction with the marketing groups have made attempts to understand the customer view of quality. all of these different ongoing activities to understand quality from the various perspectives have made the field even more enriching and exciting. the fourth workshop on software quality aims to bring together academic, industrial and commercial communities interested in software quality topics to discuss the different technologies being defined and used in the software quality area.
models and processes for the evaluation of off-the-shelf components -- mpec'05. this workshop summary presents an overview of the one-day international workshop on models and processes for the evaluation of off-the-shelf components (mpec'05), held in conjunction with the 27th international conference on software engineering (icse'05). details about mpec'05 may be found at http://www.lsi.upc.edu/events/mpec/.
use of state diagrams to engineer communications software. this paper presents our experience with a variation on the use of state diagrams in the development of a communications system. the following techniques are described: - state diagram notation functions as the design language used to describe the functional specification of major program modules. - these modules are coded in a high-level language using the state diagrams as the program structure and specification. - the actual programs are used as input to a simulator which performs a structured walk-through. - automatically produced state diagrams from final software serve as documentation and act as a check on meeting initial system requirements.
structure charts and program correctness proofs. structured design has been widely used in the software industry with good results. on the other hand, program development hand-in-hand with program-correctness proof techniques has shown promising signs for future software development. this paper attempts to bridge the gap between structured design and program development with proofs. three basic constructs used in structure charts have been modified to incorporate guarded commands. software design can be proved informally using the modified structure charts. with this technique, the benefits of both structured design and program correctness proofs can be applied to the development of large programs.
on the education of future software engineers. the education of software engineers more and more addresses organizational and management issues, like for instance modeling the business structure and environment which will receive a new software system. the teaching to software engineering students of modeling technologies based on standards like uml and the rational unified process, stressing the focus on designing business-oriented management of software services, raises novel questions than need to be addressed.
automated refactoring to introduce design patterns. software systems have to be flexible in order to cope with evolving requirements. however, since it is impossible to predict with certainty what future requirements will emerge, it is also impossible to know exactly what flexibility to build into a system. design patterns are often used to provide this flexibility, so this question frequently reduces to whether or not to apply a given design pattern. we address this problem by developing a methodology for the construction of automated transformations that introduce design patterns. this enables a programmer to safely postpone the application of a design pattern until the flexibility it provides becomes necessary. our approach deals with the issues of reuse of existing transformations, preservation of program behaviour and the application of the transformations to existing program code.
error recovery in systems of communicating processes. this paper deals with some of the relevant problems concerning the backward recovery of autonomous processes. the tools for the description of the past history of a system are formally defined, and an implementation is outlined.
calibrating the cocomo ii post-architecture model. the cocomo ii model was created to meet the need for a cost model that accounted for future software development practices. this paper describes some of the experiences learned in calibrating cocomo ii post-architecture model from eighty-three observations. the results of the multiple regression analysis, their implications, and a future calibration strategy are discussed
a comparison of data flow path selection criteria. a number of path selection testing criteria have been proposed throughout the years. unfortunately, little work has been done on comparing these criteria. to determine what would be an effective path selection criterion for revealing errors in programs, we have undertaken an evaluation of these criteria. this paper reports on the results of our evaluation for those path selection criteria based on data flow relationships. we show how these criteria relate to each other, thereby demonstrating some of their strengths and weaknesses.
composition patterns: an approach to designing reusable aspects. requirements such as distribution or tracing have an impact on multiple classes in a system. they are cross-cutting requirements, or aspects. their support is, by necessity, scattered across those multiple classes. a look at an individual class may also show support for cross-cutting requirements tangled up with the core responsibilities of that class. scattering and tangling make object-oriented software difficult to understand, extend and reuse. though design is an important activity within the software lifecycle with well-documented benefits, those benefits are reduced when cross-cutting requirements are present. this paper presents a means to mitigate these problems by separating the design of cross-cutting requirements into composition patterns. composition patterns require extensions to the uml, and are based on a combination of the subject-oriented model for composing separate, overlapping designs, and uml templates. this paper also demonstrates how composition patterns map to one programming model that provides a solution for separation of cross-cutting requirements in code&mdash;aspect-oriented programming. this mapping serves to illustrate that separation of aspects may be maintained throughout the software lifecycle.
the design of a template structure for a generalized data structure definition facility. a template structure capable of defining the runtime configuration of general data structures, e.g. arrays (homogeneous and non-homogeneous), cells, stacks, queues, trees, and general lists (graphs), for a generalized data structure definition facility that has practical utility in applications where thousands of data structures can be in existence at any given time is described. an important aspect of this template structure organization is that like instances of a data structure allocated at runtime share a common template rather than each allocated instance of a data structure having its own individual template. the motivation for sharing templates is derived from the fact that large numbers of data structures can be active at runtime, and templates can occupy a considerable amount of storage (in some instances a template can occupy as much or more storage than the data structure elements themselves). the importance of template sharing in a paging system, and the capability of the template structure for facilitating the design and implementation of general operations such as insert and delete are discussed.