waashk/dblp huggingface dataset:
multivariate visualization in observation-based testing. we explore the use of multivariate visualization techniques to support a new approach to test data selection, called observation-based testing. applications of multivariate visualization are described, including: evaluating and improving synthetic tests; filtering regression test suites; filtering captured operational executions; comparing test suites; and assessing bug reports. these applications are illustrated by the use of correspondence analysis to analyze test inputs for the gnu gcc compiler.
blending object-z and timed csp: an introduction to tcoz. object-z is an extension to the z language designed to facilitate specification in an object-oriented style. it is an excellent tool for modeling data and algorithms, but its object semantics are single threaded and operations are atomic. therefore, it is difficult to use object-z to capture the behaviour of concurrent real-time reactive systems. on the other hand, timed csp is good at modeling real-time concurrent behaviour, but has little support for modeling the state of a complex system. this paper introduces a blending of object-z and timed csp, known as tcoz. the blended notation is particularly suited for specifying complex systems whose components have their own thread of control
automated generation of test programs from closed specifications of classes and test cases. most research on automated specification-based softwaretesting has focused on the automated generation oftest cases. before a software system can be tested, it must beset up according to the input requirements of the test cases.this setup process is usually performed manually, especiallywhen testing complex data structures and databases.after the system is properly set up, a test execution tool runsthe system according to the test cases and pre-recorded testscripts to obtain the outputs, which are evaluated by a testevaluation tool.this paper complements the current research on automatedspecification-based testing by proposing a schemethat combines the setup process, test execution, and test validationinto a single test program for testing the behavior ofobject-oriented classes. the test program can be generatedautomatically given the the desired test cases and closedspecifications of the classes. with closed specifications, everyclass method is defined in terms of other methods whichare, in turn, defined in their own class specifications. thecore of the test program generator is a partial-order plannerwhich plans the sequence of instructions required in thetest program. the planner is, in turn, implemented as a tree-searchalgorithm. it makes function calls to the omega calculatorlibrary, which solves the constraints given in thetest cases. a first-cut implementation of the planner hasbeen completed, which is able to handle simple arithmeticsand existential quantifications in the class specifications. asoundness and completeness proof sketch of the planner isalso provided in this paper.
on what exactly is going on when software is developed step-by-step. in this paper we present a (necessarily) informal and brief description of formal concepts which lend mathematical support to a paradigm of software development. some important obligations which must be met by the software developers are pointed out. correspondences between widely adhered to practices and their mathematical counterparts are identified and explained.
a case study in root cause defect analysis. there are three interdependent factors that drive our software development processes: interval, quality and cost. as market pressures continue to demand new features ever more rapidly, the challenge is to meet those demands while increasing, or at least not sacrificing, quality. one advantage of defect prevention as an upstream quality improvement practice is the beneficial effect it can have on interval: higher quality early in the process results in fewer defects to be found and repaired in the later parts of the process, thus causing an indirect interval reduction.we report a retrospective root cause defect analysis study of the defect modification requests (mrs) discovered while building, testing, and deploying a release of a transmission network element product. we subsequently introduced this analysis methodology into new development projects as an in-process measurement collection requirement for each major defect mr.we present the experimental design of our case study discussing the novel approach we have taken to defect and root cause classification and the mechanisms we have used for randomly selecting the mrs to analyze and collecting the analyses via a web interface. we then present the results of our analyses of the mrs and describe the defects and root causes that we found, and delineate the countermeasures created to either prevent those defects and their root causes or detect them at the earliest possible point in the development process.we conclude with lessons learned from the case study and resulting ongoing improvement activities.
developing use cases and scenarios in the requirements process. scenarios are often used for discovering requirements using established techniques, but how such scenarios are initially developed is not so well understood. this experience paper reports the application of one scenario-based approach - rescue - to discover requirements for dman, an air traffic management system for the uk's national air traffic services. a retrospective analysis of the dman use cases, scenarios and requirements artifacts revealed the importance of diverse information sources in the specification of use cases that enabled systematic requirements discovery. results were used to explore 3 research questions that arose in previous studies. the paper reports lessons from this experience and offers guidelines that practitioners can apply in their requirements processes and academics can use to inform their research.
monitoring and control in scenario-based requirements analysis. scenarios are an effective means for eliciting, validating and documenting requirements. at the requirements level, scenarios describe sequences of interactions between the software-to-be and agents in the environment. interactions correspond to the occurrence of an event that is controlled by one agent and monitored by another.this paper presents a technique to analyse requirements-level scenarios for unforeseen, potentially harmful, consequences. our aim is to perform analysis early in system development, where it is highly cost-effective. the approach recognises the importance of monitoring and control issues and extends existing work on implied scenarios accordingly. these so-called input-output implied scenarios expose problematic behaviours in scenario descriptions that cannot be detected using standard implied scenarios. validation of these implied scenarios supports requirements elaboration. we demonstrate the relevance of input-output implied scenarios using a number of examples.
creative requirements: invention and its role in requirements engineering. requirements is too often seen as a "stenographer's task", one where the requirements engineer passively listens and records while the stakeholders state their needs. however, this approach relies on stakeholders knowing what they need, and what they want. experience tells us that except for rare visionaries, people do not know what they want until they see it. many of the useful products that we take for granted today, did not come about from the stakeholders' imagination, but from an invention. in this tutorial we explain and illustrate how to use creative techniques to invent requirements that result in more useful, usable and competitive products. we provide a guide for invention, and show participants how to use this guide to invent innovative requirements for a familiar system.
agent-based tactics for goal-oriented requirements elaboration. goal orientation is an increasingly recognized paradigm for eliciting, structuring, analyzing and documenting system requirements. goals are statements of intent ranging from high-level, strategic concerns to low-level, technical requirements on the software-to-be and assumptions on its environment. achieving goals require the cooperation of agents such as software components, input/output devices and human agents. the assignment of responsibilities for goals to agents is a critical decision in the requirements engineering process as alternative agent assignments define alternative system proposals.the paper describes a systematic technique to support the process of refining goals, identifying agents, and exploring alternative responsibility assignments. the underlying principles are to refine goals until they are assignable to single agents, and to assign a goal to an agent only if the agent can realize the goal.there are various reasons why a goal may not be realizable by an agent, e.g., the goal may refer to variables that are not monitorable or controllable by the agent. the notion of goal realizability is first defined on formal grounds; it provides a basis for identifying a complete taxonomy of realizability problems. from this taxonomy we systematically derive a catalog of tactics for refining goals and identifying agents so as to resolve realizability problems. each tactics corresponds to the application of a formal refinement pattern that relieves the specifier from verifying the correctness of refinements in temporal logic.our techniques have been used in two case studies of significant size; excerpts are shown to illustrate the main ideas.
precise modeling of design patterns in uml. prior research attempts to formalize the structure ofobject-oriented design patterns for a more precisespecification of design patterns. it also allows automationsupport to be developed for user-defined design patternsin the future case tools. targeting to a particular type ofautomation (e.g. verification of pattern instances),previous specification approaches over-specify patternstructures to a certain extend. over-specification makespattern specification ambiguous and disallows thespecification language to be used for specifyingcompound patterns. in this paper, we present thestructural properties of design patterns which reveal thetrue abstract nature of pattern structures. to supportthese properties so as to solve the over-specificationproblem, we propose an extension to uml 1.5 (basicallyuml 1.4 with action semantics). the specialization andrefining mechanism of uml provides also a smoothsupport for the instantiation, refinement and integrationof pattern structures specified in uml. our work makesno significant extension to the uml 1.5 meta-model butmore in a uml profile approach to ease the migration ofour work to uml 2.0, which has not yet officiallyreleased by omg during this work.
high-pressure steam engines and computer software. the introduction of computers into the control of potentially dangerous devices has led to a growing awareness of the possible contribution of software to serious accidents. the number of computer-related accidents so far has been small due to the restraint shown in introducing computers into safety-critical control loops. however, as the economic and technological benefits of using computers become more widely accepted, their use is increasing dramatically. we need to ensure that computers are introduced into safety-critical systems in the most responsible way possible and at a speed that does not expose people to undue risk. risk induced by technological innovation existed long before computers; this is not the first time that humans have come up with an extremely useful new technology that is potentially dangerous. studying parallels in the early development of high-pressure steam engines and of software engineering can help.
decision table programming and reliability. the language in which programs are written influence their structure, style, reliability and verifiability. in this paper, we discuss the use of decision tables as a programming language, and related reliability questions. while both good and bad programs can be written in any language, it is suggested here that decision table programming is worth more serious consideration for general purpose computing.
mohca-java: a tool for c++ to java conversion support. as java increases in popularity and maturity, many people find it desirable to convert legacy c++ or c programs to java. our hypothesis is that a tool which performs rigorous analysis on a c++ program, providing detailed output on the changes necessary, will make conversion a much more efficient and reliable process. mohca-java is such a tool. it performs detailed analysis on a c++ abstract syntax tree; the parameters of the analysis can be specified and extended very quickly and easily using a rule-based language. we have found that mohca-java is very useful for identifying and implementing source code changes, and that its extensibility is a very important factor, specially to adapt the tool to assist in the conversion of c++ code that makes extensive use of libraries to java code that uses similar libraries.
beyond albe/p: language neutral form. albe/p is a language-based crt editor for pascal programs. the crt screen serves as a window through which a programmer can view and modify a &ldquo;pretty-printed&rdquo; picture of any part of a pascal program. the albe/p system differs from conventional screen-oriented text editors in that the program is stored as a pascal parse tree and the editing operations are designed specifically for the pascal language. moreover, because albe/p is language-based, it will not accept programs with local syntax errors (e.g., ill-formed expressions) or global errors (e.g., undeclared variables). the system is also an effective tool for developing and maintaining application systems and subroutine packages in multiple language environments. programs can be entered in language-neutral form (lnf), a pascal subset with language features common to c, pl/i, and algol. then, albe will generate a pascal program to be run and debugged under the host operating system. when program development is complete, albe/lnf will generate equivalent programs for the desired target languages and operating system environments. currently, albe/lnf supports pascal, c, and fortran under vax/vms.
an empirical study on decision making in off-the-shelf component-based development. component-based software development (cbsd) is becoming more and more important since it promotes reuse to higher levels of abstraction. as a consequence, many components are available being either open-source software (oss) or commercial-off-the-shelf (cots). however, it is still unclear how the decision for acquiring oss or cots components is made in practice. this paper describes an empirical study on why project decision-makers selected cots instead of oss components, or vice versa. the study was performed as an international survey in norway, italy and germany. it focused on decision making on using off-the-shelf (ots) components. we have gathered answers from 83 projects using only cots components and 44 projects using only oss components. results of this study show significant differences and commonalities of integrating oss or cots components. moreover, the study illustrates several research questions that warrant future research.
supporting program comprehension using semantic and structural information. the paper focuses on investigating the combined use of semantic and structural information of programs to support the comprehension tasks involved in the maintenance and reengineering of software systems. here, semantic refers to the domain specific issues (both problem and development domains) of a software system. the other dimension, structural, refers to issues such as the actual syntactic structure of the program along with the control and data flow that it represents. an advanced information retrieval method, latent semantic indexing, is used to define a semantic similarity measure between software components. components within a software system are then clustered together using this similarity measure. simple structural information (i.e., file organization) of the software system is then used to assess the semantic cohesion of the clusters and files, with respect to each other. the measures are formally defined for general application. a set of experiments is presented which demonstrates how these measures can assist in the understanding of a nontrivial software system, namely a version of ncsa mosaic.
a risk-driven method for extreme programming release planning. xp (extreme programming) has become popular for iid (iteration and increment development). it is suitable for small teams, lightweight projects and vague/volatile requirements. however, some challenges are left to developers when they desire to practise xp. a critical one of them is constructing the release plan and negotiating it with customers. in this paper, we propose a risk-driven method for xp release planning. it has been applied in a case study and the results show the method is feasible and effective. xp practicers can follow it to decide a suitable release plan and control the development process.
source viewer 3d (sv3d) - a framework for software visualization. source viewer 3d is a software visualization framework that uses a 3d metaphor to represent software system and analysis data. the 3d representation is based on the seesoft pixel metaphor. it extends the original metaphor by rendering the visualization in a 3d space. new, object-based manipulation methods and simultaneous alternative mappings are available to the user.
experiences and results from initiating field defect prediction and product test prioritization efforts at abb inc. quantitatively-based risk management can reduce the risks associated with field defects for both software producers and software consumers. in this paper, we report experiences and results from initiating risk-management activities at a large systems development organization. the initiated activities aim to improve product testing (system/integration testing), to improve maintenance resource allocation, and to plan for future process improvements. the experiences we report address practical issues not commonly addressed in research studies: how to select an appropriate modeling method for product testing prioritization and process improvement planning, how to evaluate accuracy of predictions across multiple releases in time, and how to conduct analysis with incomplete information. in addition, we report initial empirical results for two systems with 13 and 15 releases. we present prioritization of configurations to guide product testing, field defect predictions within the first year of deployment to aid maintenance resource allocation, and important predictors across both systems to guide process improvement planning. our results and experiences are steps towards quantitatively-based risk management.
a bayesian approach to diagram matching with application to architectural models. it system architectures, as well as other systems, are often described by formal models or informal diagrams. in practice, there are often a number of versions of a model, e.g. for different views of a system, divergent variants, or a series of revisions. understanding how versions of a model correspond or differ is crucial, yet little work has been done on automated assistance for matching models and diagrams.we have designed a framework based on bayesian methods for finding these correspondences automatically. we represent models and diagrams as graphs whose nodes have attributes such as name, type, connections, and containment relations, and we have developed probabilistic models for rating the quality of candidate correspondences based on various features of the nodes in the graphs. given the probabilistic models, we can find high quality correspondences using search algorithms. preliminary experiments focusing on architectural models suggest that the technique is promising.
light-weight context recovery for efficient and accurate program analyses. to compute accurate information efficiently for programs that use pointer variables, a program analysis must account for the fact that a procedure may access different sets of memory locations when the procedure is invoked under different callsites. this paper presents light-weight context recovery, a technique that can efficiently determine whether a memory location is accessed by a procedure under a specific callsite. the paper also presents a technique that uses this information to improve the precision and efficiency of program analyses. our empirical studies show that (1) light-weight context recovery can be quite precise in identifying the memory locations accessed by a procedure under a specific call-site and (2) distinguishing memory locations accessed by a procedure under different callsites can significantly improve the precision and the efficiency of program analyses on programs that use pointer variables.
breaking the ice for agile development of embedded software: an industry experience report. a software engineering department in a daimler-chrysler business unit was highly professional at developing embedded software for busses and coaches.however, customer specific add-ons were a regularsource of hassle. simple as they are, those individualrequirements have to be implemented in hours or daysrather than weeks or months. poor quality or late uploadinto the bus hardware would cause serious cost andoverhead. established software engineering methodswere considered inadequate and needed to be cut short.agile methods offer guidance when quality, flexibilityand high speed need to be reconciled. however, we didnot adopt any full agile method, but added single agilepractices to our "process improvement toolbox". wesuggested a number of classical process improvementactivities (such as more systematic documentation andmeasurement) and combined them with agile elements(e.g. test first process). this combination seemed tofoster acceptance of agile ideas and may help us to breakthe ice for a cautious extension of agile processimprovement.
software engineering provisioning process. the main theme of the 8th international conference on software engineering is the &ldquo;establishment of a better understanding of the software process and its improvement through the provision of better models, methods and tools.&rdquo; this paper addresses the second half of this theme by defining the issues involved with making strategic improvements to environments and suggesting a process for &ldquo;provisioning&rdquo; (or providing) better computer-aided software engineering methods and tools. the paper focuses primarily on the process for transforming existing, large to very large scale software development and support environments into conceptual &ldquo;software factories.&rdquo; to achieve this goal, arguments are made for strategically planning and developing well architected, modifiable software engineering environments. this is considered a prerequisite to effective &ldquo;provisioning&rdquo; of new and improved methods and tools. taken as a whole, the paper should be useful to software developers, tool providers and major software buyers alike. through typical environment evolution scenarios and concrete examples, many useful suggestions are provided to each of these players on how they can assist in the software engineering improvement process.