waashk/dblp huggingface dataset:
automated construction of testing and analysis tools. many software testing and analyse's tools manipulate graph representations of programs, such as abstract syntax trees or abstract semantics graphs. hand-crafting such tools in conventional programming languages can be difficult, error prone, and time consuming. our approach is to use application generators targeted for the domain of graph-representation-based testing and analysis tools. moreover, we generate the generators themselves, so that the development of tools based on different languages and/or representations can also be supported better. in this paper we report on our experiences in developing a system called aria that generates testing and analysis tools based on an abstract semantics graph representation for c and c++ cabled reprise. aria itself was generated by the genoa system. we demonstrate the utility of aria and, thereby, the pourer of our approach, by showing aria's use in the development of a tool that derives control dependence graphs directly from reprise abstract semantics graphs
forcing behavioral subtyping through specification inheritance. a common change to object-oriented software is to add a new type of data that is a subtype of some existing type in the program. however, due to message passing, unchanged pearls of the program may now call operations of the new type. to avoid reverification of unchanged code, such operations should have specifications that are related to the specifications of the appropriate operations in their supertypes. this paper presents a specification technique that uses inheritance of specifications to force the appropriate behavior on the subtype objects. this technique is simple, requires little effort by the specifier, and avoids reverification of unchanged code. we present two notions of such behavioral subtyping, one of which is new. we show how to use these techniques to specify examples in c++.
backwards-compatible array bounds checking for c with very low overhead. the problem of enforcing correct usage of array and pointer references in c and c++ programs remains unsolved. the approach proposed by jones and kelly (extended by ruwase and lam) is the only one we know of that does not require significant manual changes to programs, but it has extremely high overheads of 5x-6x and 11x-12x in the two versions. in this paper, we describe a collection of techniques that dramatically reduce the overhead of this approach, by exploiting a fine-grain partitioning of memory called automatic pool allocation. together, these techniques bring the average overhead checks down to only 12% for a set of benchmarks (but 69% for one case). we show that the memory partitioning is key to bringing down this overhead. we also show that our technique successfully detects all buffer overrun violations in a test suite modeling reported violations in some important real-world programs.
finding failures by cluster analysis of execution profiles. we experimentally evaluate the effectiveness of using cluster analysis of execution profiles to find failures among the executions induced by a set of potential test cases. we compare several filtering procedures for selecting executions to evaluate for conformance to requirements. each filtering procedure involves a choice of a sampling strategy and a clustering metric. the results suggest that filtering procedures based on clustering are more effective than simple random sampling for identifying failures in populations of operational executions, with adaptive sampling from clusters being the most effective sampling strategy. the results also suggest that clustering metrics that give extra weight to unusual profile features are most effective. scatter plots of execution populations, produced by multidimensional scaling, are used to provide intuition for these results.
software visualization. this half-day tutorial gives an overview of the current state-of-the-art in software visualization. software visualization encompasses the development and evaluation of methods for graphically representing different aspects of software, including its structure, its execution, and its evolution. in contrast to visual programming and diagramming for software design, software visualization is not so much concerned with the construction, but with the analysis of programs and their development process. software visualization combines techniques from areas like software engineering, programming languages, data mining, computer graphics, information visualization and human-computer interaction. topics covered in this tutorial include static program visualization, algorithm animation, visual debugging, as well as the visualization of the evolution of software. in particular we identify common principles illustrated by many examples and give pointers to tools available today.
computer-assisted assume/guarantee reasoning with verisoft. we show how the state space exploration tool verisoft can be used to analyze parallel c/c++ programs compositionally. verisoft is used to check assume/guarantee specifications of parallel processes automatically. the analysis is meant to complement standard assume/guarantee reasoning which is usually carried out solely with "pencil and paper". while a successful analysis does not always imply the general correctness of the specification, it increases the confidence in the verification effort. an unsuccessful analysis always produces a counterexample which can be used to correct the specification or the program. verisoft's optimization and visualization techniques make the analysis relatively efficient and effective.
an empirical study of an informal knowledge repository in a medium-sized software consulting company. numerous studies have been conducted on design and architecture of knowledge repositories. this paper addresses the need for looking at practices where knowledge repositories are actually used in concrete work situations. this insight should be used when developing knowledge repositories in the future.through methods inspired by ethnography this paper investigates how an unstructured knowledge repository is used for different purposes by software developers and managers in a medium-sized software consulting company. the repository is a part of the company's knowledge management tool suite on the intranet. we found five distinct ways of using the tool, from solving specific technical problems to getting an overview of competence in the company. we highlight the importance of informal organization and the social integration of the tool in the daily work practices of the company.
progressive open source. the success of several open source&trade; software systems, e.g., apache, bind, emacs, and linux, has recently sparked interest in studying and emulating the software engineering principles underlying this innovative development and use model. certain aspects of the open source development method, e.g., community building, open discussions for requirements and features, and evolvable and modular designs are having fundamental and far reaching consequences on general software engineering practices.to leverage such open source methods and tools, we have defined an innovative software engineering paradigm for large corporations: progressive open source (pos). pos leverages the power of open source methods and tools for large corporations in a progressive manner: starting from completely within the corporation, to include partner businesses, and eventually complete open source. in this paper we present the design goals and principles for pos. we illustrate pos with two programs in hp: corporate source and the collaborative development program (cdp). we present early results from both these programs suggesting the power and necessity of pos for all modern large corporations.
redesigning legacy applications for the web with uwat+: a case study. this paper reports on a case study of redesigning a legacy application for the web using the ubiquitous web applications design framework with an extended version of its transaction design model (uwat+). web application design methodologies hold the promise of engineering high-quality and long-lived web systems and rich internet applications. however, many such techniques focus solely on green-field development, and do not properly address the situation of leveraging the value locked in legacy systems. the redesign process supported by uwat+ holistically blends design recovery technologies for capturing the know-how embedded in the legacy application with forward design methods particularly well suited for web-based systems. the case study highlights some of the benefits of using uwat+ in this context, as well as identifying possible areas for improvement in the redesign process and opportunities for tool automation to support it.
integrated support for project management. conventional `off-line` project management tools are being overtaken by integrated project support environments which are capable of imposing more direct control over project activities. such environments can lead to a more systematic approach to planning, monitoring and controlling software development. this paper describes the facilities offered by istar for integrated support of project management.
software engineering in avionics applications. flight control for commercial aircraft has to fulfil stringent requirements. this paper describes first the main lines of the system development process in order to situate the software validation problem which is only a part of the whole validation exercise. the appropriate methods and tools used in the different software development stages are then presented. a great deal of our attention was in the software analysis stage (preliminary design) for which a software decomposition approach, a software integration strategy and a managerial procedure was developed. real-time testing also deserved a great deal of effort. a full set of real-time facilities was created around our airborne computer (ump 7800) which is a software oriented machine whose essential features are roughly described in the paper. special emphasis is given to a hardware device (trace) connected to the computer bus which is capable to check and record critical numerical data and program paths. finally some quantitative evaluation of the methodologies we use are given based on some of our avionics projects.
using the balanced scorecard process to compute the value of software applications. this paper describes a method that will provide practical help for it managers and other enterprise executives who want to determine the value of their software projects. a set of measures is described that can help the it manager determine the value of it projects, either at the time a project is initiated or at the time the project is operational. this paper identifies relevant performance measures used in the balanced scorecard process and then maps them to it benefits: which are categorized by strategic, informational, and transactional dimensions. the appropriate measure can be identified and value quantified based upon the expected it benefit.
the leap load and test driver. leap is a facility for testing interactive applications that are implemented on ibm system/360 and system/370 computers; it simulates concurrently the actions of several ibm 3270-type terminals and of their operators. leap allows one to organize, in a systematic and efficient fashion, a large-scale, repeatable testing program for such an interactive application system. leap is one of the tools of the programmer's work-bench. it operates under the unix time sharing system; all test preparation, testing, and test analysis is performed at a unix terminal. leap can be used for both regression (functional) testing and load (stress and performance) testing. several post-test analysis tools are provided.
an introduction to the programmer's workbench. the programmer's workbench (pwb) is a specialized computing facility dedicated to satisfying the needs of developers of computer programs. the pwb might well be called a &ldquo;human-end&rdquo; computer; like &ldquo;front-end&rdquo; and &ldquo;back-end&rdquo; computers, it improves productivity by efficient specialization. it provides a convenient working environment and a uniform set of programming tools to a diverse group of programming projects. these projects produce software for various &ldquo;target&rdquo; computers, including ibm system/370 and univac 1100 systems of much greater size than the pwb machines. the projects range in size from several people up to several hundred. the first pwb machine was installed in october, 1973; usage, acceptance, and interest have grown rapidly since that time. the pwb currently supports about 110 time-sharing terminals, utilizing a network of four dec pdp-11 computers, all running the unix time-sharing system. the pwb adds tools to unix to support large projects. this paper gives an overview of the pwb and its development; further details appear in the five following companion papers [bia76a, dol76b, knu76a, mas76a, mas76b].
imposing a memory management discipline on software deployment. the deployment of software components frequently failsbecause dependencies on other components are not declaredexplicitly or are declared imprecisely. this resultsin an incomplete reproduction of the environment necessaryfor proper operation, or in interference between incompatiblevariants. in this paper we show that these deploymenthazards are similar to pointer hazards in memory models ofprogramming languages and can be countered by imposinga memory management discipline on software deployment.based on this analysis we have developed a generic, platformand language independent, discipline for deploymentthat allows precise dependency verification; exact identification of component variants; computation of complete closures containing all components on which a component depends;maximal sharing of components between such closures;and concurrent installation of revisions and variantsof components. we have implemented the approach in thenix deployment system, and used it for the deployment of alarge number of existing linux packages. we compare its effectivenessto other deployment systems.
a logical framework for design composition. the design of a large component-based software system typically involves the composition of different components. the lack of rigorous reasoning about the correctness of composition is an important barrier towards the promise of &ldquo;plug and play&rdquo;. in this paper, we describe a rigorous logic framework to reason about component compositions. we focus our analysis on design components, such as design patterns, which have been used by a large number of applications. we also propose methods to verify structural and behavioral composition correctness.
state, event, time and diagram in system modeling. the design of complex systems requires powerful mechanisms for modeling state, concurrent events, and real-time behavior; as well as for visualising and structuring systems in order to control complexity. methods integration has become a recent research trend in software specification and design. in the graphical area, many object-oriented methods have merged into one, the unified modeling language (uml) which combines various diagrammatic modeling techniques to model static and dynamic aspects of software systems. although traditional formal methods have not scale-up well, new integrated formal methods show great promise. this tutorial will present the state of the art in formal modeling techniques (state-based object-z and event-based timed csp), their integration (tcoz), and transformation techniques from the integrated formalism to uml diagrams. an xml web environment for projecting integrated formal models to uml diagrams will also be demonstrated.
from semantic web to expressive software specifications: a modeling languages spectrum. many researchers at w3c currently focus on developing the next generation of the web --- the semantic web. the development of the web ontology languages, rdf, owl and swrl, is reminiscent of the early development of system specification languages in software engineering communities. indeed, from the expressiveness point of view, web ontology languages are subsets of alloy, uml/ocl, vdm, z and object-z. one can futher predict that the modeling languages for capturing the behaviours of the semantic web services and agents can be drawn from the rich collections of software dynamic modeling techniques, i.e., state machines, process algebra and integrated design methods. this tutorial will present a concise modeling languages spectrum that includes a few key representative modeling languages ranging from simple static web ontology modeling techniques to expressive dynamic integrated modeling techniques. comparisons and transformations between those languages will be discussed. furthermore, based on transformation approaches, the latest research results on applying software modeling techniques and tools to the semantic web domain will be also demonstrated.
highspec: a tool for building and checking ozta models. highspec is an interactive system for composing and checking ozta specifications. the integrated high level specification language, ozta, is a combination of object-z (oz) and timed automata (ta). building on the strength of object-z's in specifying data structures and timed automata's in modelling dynamic and real-time behaviors, ozta is well suited for presenting complete and coherent requirement models for complex real-time systems. highspec supports editing, type-checking as well as projecting ozta models into ta models and alloy models so that ta model checkers-uppaal and the alloy analyzer can be utilized for verification. most importantly, highspec supports a novel yet effective mechanism advocated by ozta for structural ta design, i.e., using a set of composable timed patterns to capture high level timing requirements and process behaviors and generate the ta part of model in a top-down way. highspec can also generate latex document as an alternative media for the spread and read of established ozta models.
verifying daml+oil and beyond in z/eves. semantic web, the next generation of web, gives datawell-defined and machine-understandable meaning so thatthey can be processed by remote intelligent agents cooperatively.ontology languages are the building blocks of semanticweb as they prescribe how data are defined and related.the existing reasoning and verification tools for semanticweb are improving however still elementary. we believethat semantic web can be a novel application domainfor software modeling languages and tools. z is aformal modeling language for specifying software systemsand z/eves is a proof tool for z. in this paper, we firstlypresent z semantics for ontology language daml+oil.this semantic model is embedded as a z section daml2zinz/eves, which serves as an environment for checking andverifying web ontologies. then we present a tool for automaticallytransforming ontology documents into the specializedz codes understood by z/eves. finally, we usea recent real application, the military plan ontologies, todemonstrate the different reasoning tasks that z/eves canperform. furthermore, undiscovered errors in the originalontologies were found by z/eves and some of these errorsare even beyond semantic web modeling and reasoning capabilities.
practical applications of a syntax directed program manipulation environment. we present applications in various domains of a system built around a syntax directed editor: the mentor system. the main characteristics of the system are the abstract representation of data, programmability of the command language, and language independance. the applications presented belong to the area of program editing and manipulation, extensions of programming languages through the development of preprocessors, processing of multi-formalism documents and program portability.
iteration in the software process: review of the 3rd international software process workshop. the 3rd international process workshop, with the theme 'iteration in the software process' was held in colorado in november 1986. iteration, which was taken to subsume 'backtracking', 'rework', 'repetition' and so on, seems to be central to the software process; selecting it as a main topic allowed intensive consideration of many of the key problems that face software engineering. much of the workshop discussion focused on the concept of executable representations of the process, exemplified by osterweil's process programs. the general conclusion was that exploring the process programming paradigm and its limitations would prove a fruitful area for investigation in the near term.
approach and case study of requirement analysis where end users take an active role. in the traditional approach to software analysis, systems analysts interview end users to capture requirements. the authors propose an approach called automated user requirements acquisition (aura) where end users take an active role in analysis by identifying requirements. this approach takes advantage of end users domain knowledge. aura uses a question-and-answer model to guide end users in describing their problem. additionally, aura provides problem domain knowledge to suggest answers for the questions. the business application domain was selected to explain and demonstrate the approach. while the aura approach can benefit any analysis technique, an object-oriented analysis technique was selected as the underlying method. a prototype tool, aura-biz, was developed to demonstrate aura in the business domain. aura-biz was evaluated through a case study where end users created the analyses of their business problem. the data collected showed that the end users successfully modeled their problem by following the questions and using the suggestions
software engineering for user interfaces. the discipline of software engineering can be extended in a natural way to deal with the issues raised by a systematic approach to the design of human-machine interfaces. two main points are made: that the user should be treated as part of the system being designed, and that projects should be organized to take account of the current (small) state of a priori knowledge about how to design interfaces.
simulation in software engineering training. simulation is frequently used for training in many application areas like aviation and economics, but not in software engineering. we present the sesam project which focuses on software engineering education using simulation. in the sesam project a simulator was developed. using this simulator, a student can take the role of a software project manager. the simulated software project can be finished within a couple of hours because it is simulated in &ldquo;quick-motion&rdquo; mode.in this paper, the background and goals of the sesam project are presented. a new simulation model, the so called qa model, is introduced. the model behavior is demonstrated by investigating and comparing different strategies for software development. the results of experiments based on the qa model are reported. finally, conclusions are drawn from the experiments and future work is outlined.