waashk/dblp huggingface dataset:
empirical interval estimates for the defect content after an inspection. we present a novel method for estimating the number of defects contained in a document using the results of an inspection of the document. the method is empirical, being based on observations made during past inspections of comparable documents. the method yields an interval estimate, that is, a whole range of values which is likely to contain the true value of the number of defects in the document. we also derive point estimates from the interval estimate. the method is validated using a known empirical inspection dataset and clearly outperforms existing approaches for estimating the defect content after inspections.
extending requirement specifications using analogy. creating the specifications for a new system is a labour intensive task. analogical reasoning provides a flexible mechanism to retrieve and adapt past specifications. previous work in applying analogical reasoning to requirement specifications has departed from the psychological foundations of analogical reasoning, introducing specific ontologies and abstract templates to constrain the reasoning process. we argue that similar results can be obtained without introducing domain specific constraints and that using analogical reasoning engines based on well-established psychological theories, such as the structure-mapping engine, will lead to better results and scale up more effectively.
pragmatic techniques for program analysis and verification. the program development system (pds) is a collection of programming tools created as an extension of the ecl programming system23. it contains components that assist the programmer in the definition and modular structuring of large programs at different levels of algorithmic abstraction. these components are supplemented by a program analysis package that produces an information pool to be used for such tasks as source-to-source optimization, semi-automated program documentation, fault detection and program verification. this paper describes the core of the analyzing package, the symbolic evaluator. in its implementation we have incorporated pragmatic methods for handling data sharing patterns, and for characterizing and reasoning about the behaviour of loops and procedures. the impact of these methods upon program verification techniques is briefly discussed.
lisfs: a logical information system as a file system. we present logical information systems (lis). a lis can be viewed as a schema-less database whose objects are described by logical formulas. objects are automatically organized according to their logical description, and logical formulas can be used for representing both queries and navigation links. the key feature of a lis is that it answers a query with a set of navigation links expressed in the same logic as the query. as navigation links are dynamically computed from any query, and can be used as query increments, it follows that querying and navigation steps can be combined in any order.we then present lisfs, a file-system implementation of a lis, where objects are files or parts of files. this has the benefit to make lis features available right now to existing applications. this implementation can easily be extended and specialized through a plug-in mechanism.finally, we present some applications in the field of personal databases (e.g., music, images, emails) and in the field of software engineering.
coverage measurement experience during function test. the authors discuss the issues of test coverage measurement in industry and justify the benefits of the measurement using a framework developed by them. some results of experiences using test coverage measurement are outlined. the function test of large-scale system software is defined and analyzed. based on the discussions of function test, a framework for analyzing the function test error removal process is developed. an experience-based error removal model and a cost model are proven to be useful tools for justifying test coverage measurement during function test. data obtained from a real project are analyzed using the framework for validation
beyond structured programming. structured programming principles are not strong enough to control complexity and guarantee high reliability of software at the module level. stronger organizing principles and stronger properties of components are needed to make significant gains in the quality of software. practical proposals, based on the definition of normal forms which have a mathematical/logical foundation, are suggested as a vehicle for constructing software that is both simpler and of higher quality with regard to clearly defined and justifiable criteria.
automated support for classifying software failure reports. this paper proposes automated support for classifying reported software failures in order to facilitate prioritizing them and diagnosing their causes. a classification strategy is presented that involves the use of supervised and unsupervised pattern classification and multivariate visualization. these techniques are applied to profiles of failed executions in order to group together failures with the same or similar causes. the resulting classification is then used to assess the frequency and severity of failures caused by particular defects and to help diagnose those defects. the results of applying the proposed classification strategy to failures of three large subject programs are reported. these results indicate that the strategy can be effective.
information systems development at the virtual global university: an experience report. in this paper, we present our experiences gained from the course "information systems development" which is entirely taught online at the virtual global university (vgu). we identify technical, economic, and pedagogical problems and challenges which are of general interest to anyone teaching software engineering online.
test procedures: a new approach to software verification. a test procedure is a formal specification of test cases to be applied to one or more target program modules. test procedures are executable. a process called the verifier applies a test procedure to its target modules and produces an exception report indicating which test cases, if any, failed. test procedures facilitate thorough software testing by allowing individual modules or arbitrary groups of modules to be thoroughly tested outside the environment in which they will eventually reside. test procedures are complete, self-contained, self-validating and execute automatically. test procedures are a deliverable product of the software development process and are used for both initial checkout and subsequent regression testing of target program modifications. test procedures are coded in a new language called tpl (test procedure language). the paper analyzes current testing practices, describes the structure and design of test procedures and introduces the fortran test procedure language.
automatic revision of formal test procedures. an automatic software test driver is a new type of software tool which controls and monitors the execution of software tests. an automatic test driver is controlled by a formal test procedure coded in a special software test language. the test procedure replaces the test data and test setup instructions of conventional testing. the specific goals of automatic test drivers are to eliminate the need for writing drivers and stubs for module and subsystem testing, to provide a standard format and language for specifying software tests, to provide a standard execution setup for software tests, and to automate the verification of test execution results. a test procedure contains input data to be supplied to the program under test and model outputs against which actual outputs of the target program are verified. typically, ninety percent or more of the text of a test procedure consists of model outputs which must be revised each time the target program is modified. the tpl/2.0 automatic software test driver described in this paper automates both the initial generation and subsequent revision of test procedure model outputs.
dynamic configuration of resource-aware services. an important emerging requirement for computing systemsis the ability to adapt at run time, taking advantage oflocal computing devices, and coping with dynamicallychanging resources. three specific technical challenges insatisfying this requirement are to (1) select an appropriateset of applications or services to carry out a userýs task, (2)allocate (possibly scarce) resources among those applications,and (3) reconfigure the applications or resource assignmentsif the situation changes. in this paper we showhow to provide a shared infrastructure that automates configurationdecisions given a specification of the userýs task.the heart of the approach is an analytical model and anefficient algorithm that can be used at run time to makenear-optimal (re)configuration decisions. we validate thisapproach both analytically and by applying it to a representativescenario.
requirements for a layered software architecture supporting cooperative multi-user interaction. layered interactive systems lend themselves to be adapted for cooperation if inter-layer communication is charged to separated connectors. point-to-point connectors can be replaced with cooperative connectors multiplexing and demultiplexing i/o between a particular layer and multiple instances of the next lower one. for this technique to be most effective, some general guidelines should be followed that support the design of good quality software where discrimination between heterogeneous functionality at the architectural level allows multiple interacting users to exploit different system features based on their role in the cooperation. this provides a sound basis for augmenting collaboration-transparent layered systems with powerful collaboration support (e.g. complex coordination policies) yet preserving separation of concerns between applicative and cooperative functionality. the paper discusses these issues both in general and with reference to their application within the csdl framework for cooperative systems design.
multibook's test environment. well engineered web based courseware and exercises provide flexibility and added value to the students, which goes beyond the traditional text book or cd-rom based courses. the multibook project explores the boundaries of customized learning materials by composing learning trails dynamically as learners have set their profile to access a course. in this paper we first give an overview of the core project ideas and illustrate them along our software engineering course. then we present a novel extension to the project's exercise environment with a graph editing component that particularly fits the needs of structure-related assignments.
contribution to simplifying the mobile agent programming. this paper introduces an experimental framework for mobile agents. it utilizes expressiveness and formal foundation of concurrent constraint programming to solve the problem of system support for dynamic rebinding of not transferable resources and inter-agent collaboration based on logic variables. proposed solutions help to make the agent-based programming easier and more straightforward and at the same time offer a basis for more sophisticated multi-agent systems.
variability management in software product line engineering. by explicitly modeling and managing variability, software product line engineering provides a systematic approach for creating a diversity of similar products at low cost, in short time, and with high quality. this tutorial focuses on the two principle differences of software product line engineering when compared to single systems development: the differentiation of two key development processes (domain engineering and application engineering) and the explicit representation and management of variability. we characterize the two processes and their main activities and introduce the orthogonal variability modeling approach (ovm). we further illustrate the ovm approach in the product line requirements engineering and product line testing activities.
designing software for ease of extension and contraction. designing software to be extensible and easily contracted is discussed as a special case of design for change. a number of ways that extension and contraction problems manifest themselves in current software are explained. four steps in the design of software that is more flexible are then discussed. the most critical step is the design of a software structure called the " uses" relation. some criteria for design decisions are given and illustrated using a small example. it is shown that the identification of minimal subsets and minimal extensions can lead to software that can be tailored to the needs of a broad variety of users.
software engineering in the development of the trident fire control system. this paper presents a short description of some of the methods and tools used in the trident fire control software development. use of a program design language (pdl), use of a high order language (hol) for programming, and the use of a schema approach to software debug are some of the highlights. this paper will discuss the trident fire control system software development effort, stressing software engineering concepts being used. specific points that will be mentioned are: 1. parallel computer - operating system development 2. use of prototypes/planned updates 3. structured design method 4. use of a higher order language 5. software test concepts 6. configuration control/v & v effort
software aging. programs, like people, get old. we can't prevent aging, but we can understand its causes, take steps to limits its effects, temporarily reverse some of the damage it has caused, and prepare for the day when the software is no longer viable. a sign that the software engineering profession has matured will be that we lose our preoccupation with the first release and focus on the long-term health of our products. researchers and practitioners must change their perception of the problems of software development. only then will software engineering deserve to be called &ldquo;engineering&rdquo;
the modular structure of complex systems. this paper discusses the organization of software that is inherently complex because of very many arbitrary details that must be precisely right for the software to be correct. we show how the software design technique known as information hiding, or abstraction, can be supplemented by a hierarchically structured document, which we call a module guide. the guide is intended to allow both designers and maintainers to identify easily the parts of the software that they must understand, without reading irrelevant details about other parts of the software. the paper includes an extract from a software module guide to illustrate our proposals.
procurement of enterprise resource planning systems: experiences with some hong kong companies. many cases of adoption of enterprise resource planning (erp) systems have been reported in the literature. some of the adopted erp systems fail to satisfy the customer's requirements, despite the high spending and substantial efforts that have been put into the adoption exercise. this is undoubtedly unsatisfactory. a way to avoid this problem is to adopt a well planned, managed, and controlled erp procurement process. this paper describes our studies of three chinese companies in hong kong which have adopted erp systems. we report the experience of these companies, and discuss how the chinese culture might have shaped the procurement practices in their erp adoption exercises.
response to undesired events in software systems. this paper discusses an approach to handling run-time errors in software systems. it is often assumed that in programs which can be proven correct, errors will not be a problem. this paper is predicted on the assumption that, even with correct programs, undesired events at run-time will continue to be a problem. routines to respond to these undesired events (ues) must be provided in reliable systems. this paper describes a program organization which aims at satisfying the following criteria: (1) ue response routines are written by each programmer in terms of the abstract machine which he uses for his normal case code. ues are reported in those terms. he is never forced to use information about the implementation of other modules in the system. (2) programs can be written so that the code for ue detection, ue correction, and normal case, are lexically separate and can be modified independently. (3) the system can evolve from an initial version that does little recovery to one which uses sophisticated recovery techniques without a change in the structure of the system. (4) even with unsophisticated recovery procedures, the task of locating the module containing a bug discovered at run-time does not require internal knowledge of many modules. (5) costs incurred because of the recovery techniques are low as no ue occurs.
experiences with an environment generation system. the authors report on research experience using the gandalf environment generation system as a prototyping vehicle for the inscape environment. a gandalf-based environment consists of four parts: a structure editor kernel, which is simply linked into each executable, a set of grammar tables describing the language to the kernel in terms of its abstract syntax, one or more concrete syntax views, and a collection of action routines written in the extension language, arl. positive aspects of the research included experimentation, incremental evolution, multiple views, the coupling of semantic and editing actions, and the use of domain-specific facilities. negative aspects consisted primarily of problems with presentation and object management
active design reviews: principles and practices. although many new software design techniques have emerged in the past 15 years, there have been few changes to the procedures for reviewing the designs produced using these techniques. this paper describes an improved technique, based on the following ideas, for reviewing designs. the efforts of each reviewer should be focussed on those aspects of the design that suit his experience and expertise. the characteristics of the reviewers needed should be explicitly specified before reviewers are selected. reviewers should be asked to make positive assertions about the design rather than simply allowed to point out defects. the designers pose questions to the reviewers, rather than vice versa. these questions are posed on a set of questionnaires that requires careful study of some aspect of the design. interaction between designers and reviewers occurs in small meetings involving 2 - 4 people rather than meetings of large groups. illustrations of these ideas drawn from the application of active design reviews to the naval research laboratory's software cost reduction project are included.
experience with application of modern software management controls. this paper presents the experience of the software development laboratory of raytheon company, submarine signal division, in applying modern software management control techniques to the development of software for real-time embedded computer systems. the paper initially describes the characteristics of the software projects during the period 1969-1979, and the ultimate use of the systems. the software is developed for embedded computers of many types and for systems requiring from one to eleven racks of electronics, and it is programmed in many languages. the systems are installed in submarines, surface ships, aircraft, shore-based facilities and weapons. the paper then summarizes development methodologies and follows with a detailed description of the software management and control techniques, which include: manpower forecasting; tailored status reports for financial, module, and cost-milestone-schedule; cost estimating; support librarian and configuration management; policies and procedures; training; and staffing and organization.
so you want brooks in your classroom? fred brooks' seminal book, "the mythical man-month" (mmm) is a firmly established classic in software engineering. many of us feel compelled to use this work to help our students appreciate and put into practice the fundamental software engineering concepts contained between its covers. this often amounts to using "passive" lesson plans such as required readings followed by lectures and exams; these rarely fully satisfy our learning objectives. rather, students often have mixed reactions to mmm with the result that it has little impact on their attitudes and practices, both in and out of the classroom. this paper outlines a more active approach to incorporating mmm into the classroom, one that we have refined over 6 years, at multiple universities and in both graduate and undergraduate courses. it includes learning objectives, a lesson plan, sample materials, an implementation discussion, and an evaluation of the approach's impact.
an experiment to assess different defect detection methods for software requirements inspections. software requirements specifications (srs) are usually validated by inspections, in which several reviewers read all or part of the specification and search for defects. we hypothesize that different methods for conducting these searches may have significantly different rates of success. using a controlled experiment, we show that a scenario-based detection method, in which each reviewer executes a specific procedure to discover a particular class of defects has a higher defect detection rate than either ad hoc or checklist methods. we describe the design, execution and analysis of the experiment so others may reproduce it and test our results for different kinds of software developments and different populations of software engineers
experiments with computer software complexity and reliability. experiments with quantitative assessment and prediction of software reliability are presented. the experiments are based on the analysis of the error and the complexity characteristics of a large set of programs. the first part of the study concerns the data collection process and the analysis of the error data and complexity measures. the relationships between the complexity profile and the error data of the procedures of the programs are then investigated with the help of discriminant statistical analysis technique. the results of these analyses show that an estimation can be derived from the analysis of its complexity profile.
design and verification of real-time systems. this paper presents a methodology for the design and verification of a class of real-time systems frequently encountered in applications of digital control. these methodologies are described in the form of a design and informal verification of a system used for navigation control of airborne vehicles. the high reliability standards required for such tasks suggest the use of fault-tolerant hardware and software. a design is presented for both an abstract version of the system running in an ideal environment and for a version running in a non-ideal fault-prone one. a specification language for real-time systems is developed as an extension of the programming language pascal, that provides for concise and clear system descriptions while preserving the degree of efficiency and portability needed to qualify as a practical high-level system implementation language. an informal verification of both designs is given.