Search

This paper studies practical reliability measurement and modeling for large commercial software systems based on test execution data collected during system testing. The application environment and the goals of reliability assessment were analyzed to identify appropriate measurement data. Various reliability growth models were used on failure data normalized by test case executions to track testing progress and provide reliability assessment. Practical problems in data collection, reliability measurement and modeling, and modeling result analysis were also examined. The results demonstrated the feasibility of reliability measurement in a large commercial software development environment and provided a practical comparison of various reliability measurements and models under such an environment. [ABSTRACT FROM AUTHOR]

We present a programming language called TCEL (Time-Constrained Event Language), whose semantics are based on time-constrained relationships between observable events. Such a semantics infers only those timing constraints necessary to achieve real-time correctness, without overconstraining the system. Moreover, an optimizing compiler can exploit this looser semantics to help tune the code, so that its worst-case execution time is consistent with its real-time requirements. In this paper we describe such a transformation system, which work$ in two phases. First, the TCEL source code is translated into an intermediate representation. Then an instruction- scheduling algorithm rearranges selected unobservable operations and synthesizes tasks guaranteed to respect the original event- based constraints. [ABSTRACT FROM AUTHOR]

This paper describes the knowledge representation and reasoning strategies in an automatic program synthesis architecture called ELF. ELF synthesizes CAD tools that automatically mute wires in VLSI circuits. The design space ELF confronts requires it to understand various physical technologies, to select an appropriate procedure-level decomposition, to choose algorithms and data structures, to manage any interdependencies, and to generate efficient code. ELF manages the design space using a variety of knowledge sources, including domain-specific knowledge. The manner in which knowledge is used determines the representation method of choice. For example, ELF uses languages to describe knowledge that is subject to modification, rules for cause-and-effect knowledge, and graphs and templates to capture knowledge interdependencies. We illustrate the effectiveness of our ideas via a tour through the synthesis steps for a specific routing tool, and a brief discussion of the performance of the resulting synthetic router as measured against an industrial tool. [ABSTRACT FROM AUTHOR]

The paper proposes a comprehensive framework for representing and using nonfunctional requirements during the development process. The framework consists of five basic components which provide for the representation of nonfunctional requirements in terms of interrelated goals. Such goals can be refined through refinement methods and can be evaluated in order to determine the degree to which a set of nonfunctional requirements is supported by a particular design. Evidence for the power of the framework is provided through the study of accuracy and performance requirements for information systems. [ABSTRACT FROM AUTHOR]

This paper presents an environment and a methodology for the design and rapid prototyping of data-intensive software applications; i.e., applications which perform substantial retrieval and update activity on persistent data. In the proposed approach, the application is formally specified using Logres, a database language which combines object-oriented data modeling and rule-based programming. These specifications are translated into Algres, an extended relational algebra, thus yielding a rapid executable prototype. Finally, Algres programs embedded into a conventional programming language interface may be converted to conventional programs operating on a commercial relational system. This methodology helps automate the conversion from declarative requirements to imperative code, performing several tasks fully automatically and reducing the probability of human errors, while integrity constraints and application specifications are expressed in a declarative language, at a very high level of abstraction. [ABSTRACT FROM AUTHOR]

This paper summarizes our experience in the Programmer's Apprentice project in applying knowledge representation and automated reasoning to support software development. We describe a system, called Cake, that comprises seven layers of knowledge representation and reasoning facilities: truth maintenance, Boolean constraint propagation, equality, types, algebra, frames, and Plan Calculus. We also include sessions with two experimental software development tools implemented using Cake: the Requirements Apprentice and the Debugging Assistant. [ABSTRACT FROM AUTHOR]

Requirements modeling depends on having available the knowledge of what should be modeled. Acquiring, or eliciting, this knowledge is recognized to be a hard problem, and different suggestions have been made to address it. In this paper we examine one such approach-viewpoint resolution. It is based on the fact that software requirements can and should be elicited from different viewpoints, and that examination of the differences resulting from them can be used as a Way of assisting in the early validation of requirements. Our research proposes a language for expressing views from different viewpoints and a set of analogy heuristics to perform a syntacticly oriented analysis of views. This analysis of views is capable of differentiating between missing information and conflicting information, thus providing support for viewpoint resolution. We also present empirical evidence Of the effectiveness of these mechanisms. [ABSTRACT FROM AUTHOR]

The hypergeometric distribution model has been proposed for estimating the number of faults initially resident in a program at the beginning of test/debugging process. However, the parameter values of the hypergeometric distribution necessary for making the estimation were previously determined by the three-dimensional exhaustive search and therefore much time was needed to get the numerical result. In this paper, six ways to estimate parameters of the hypergeometric distribution are investigated and their accuracies are examined comparatively. It is demonstrated that the least-squares sum method is the best one among those we tried and can be well applied to real test/debug data for estimating the number of faults still resident in a program after test/debugging. By this method the estimation time can be reduced greatly. [ABSTRACT FROM AUTHOR]

The performance of transaction processing systems with two-phase locking (2PL) can be degraded by transaction blocking due to lock conflicts and aborts to resolve deadlocks. This paper develops a straightforward analytic solution method, which takes into account the variability of transaction size (the number of lock requests), an issue which has been ignored in most earlier studies. We first obtain analytic expressions for the probability of lock conflict, probability of deadlock, and the waiting time per lock conflict. We then develop a family of noniterative analytic solutions to evaluate the overall system performance by considering the expansion in transaction response time due to transaction blocking. The accuracy of these solutions is verified by validation against simulation results. We also introduce a new measure for the degree of lock contention, which is a product of the mean number of lock conflicts per transaction and the mean waiting time per lock conflict (when blocked by an active transaction). It is shown that the variability in transaction size results in an increase in both measures as compared to fixed-size transactions of comparable size. It follows that performance studies of 2PL which ignore the variability in transaction size underestimate the effect of lock contention on system performance. We also provide a solution method for the case when the processing times of transaction steps are different. The solution method is used in the analysis of the two-phase transaction processing method, according to which a transaction is first executed without requesting any locks, prefetching data (from disk) for the second execution phase with locking. In high lock contention environments, this approach may result in a significant improvement in performance compared to 2PL, which is due to the reduction in lock-holding time, since no disk 10 is required in the second phase of the execution, but this is achieved at the cost of additional CPU processing due to repeated execution. [ABSTRACT FROM AUTHOR]

This paper presents analyses of early design and code change data from the Software Cost Reduction (SCR) project, a well- reported effort conducted at the Naval Research Laboratory from 1978 to 1988. The analyses are mostly time-based studies of the change data and relationships between the data and SCR personnel activity data. This analytical approach seems to allow useful insights into software design processes even when data are limited to a single software project. It also enables project personnel to notice favorable or unfavorable patterns with respect to project goals during the course of the project. Some analyses of the change data show patterns consistent with a major goal of the SCR project—the design and development of easy-to-change software. Specifically, most changes took a day or less to uncover and resolve; the majority of changes updated at most one mod- ule. Moreover, these percentages remained fairly stable. Also, no positive relationship appeared between error-correction effort and the number of days that an error remained in the SCR design documentation. Other analyses suggest that consistency may have been temporary. For example, the analyses suggest a stepwise growth in average change effort, and an increasing percentage of changes resulted in module interface updates. Certain specific ratios between SCR change data and personnel activity data show promise as possible indicators of design incompleteness. The ratios are based on data of the kinds that are typically collected on software projects. [ABSTRACT FROM AUTHOR]

Data structure diagrams are two-dimensional figures made up of lines that aim to pictorially indicate the interrelationships of the elements of a data structure. This paper collects the various rules and factors of aesthetics that go into the way we draw data structure diagrams. We formulate the various subjective factors into computable objectives and numeric parameters. These are distilled from a large number of data structure drawings as found in various textbooks. We reveal that the rules used have not reached a level of acceptance compared to the relevant rules in engineering graphics. We also outline the internal architecture of a (sub)system that we are building that helps draw data structure diagrams. [ABSTRACT FROM AUTHOR]

While the benefits of modular software development are widely acknowledged, there is little agreement as to what constitutes a good module interface. Computational complexity techniques allow us to evaluate algorithm time and space costs but offer no guidance in the design of the interface to an implementation. Yet, interface design decisions often have a critical effect on the development and maintenance costs of large software systems. In this paper we present criteria that have led us to simple, elegant interfaces. These criteria have been developed and refined through repeated practical application. We present the criteria in detail and illustrate their use with concrete examples. [ABSTRACT FROM AUTHOR]

Software size estimation has been the object of a lot of research in the software engineering community due to the need of reliable size estimates in the utilization of existing software project cost estimation models. This paper discusses the strengths and weaknesses of existing size estimation techniques, considers the nature of software size estimation, and presents a software size estimation model which has the potential for providing more accurate size estimates than existing methods. The proposed method takes advantage of a characteristic of object-oriented systems, the natural correspondence between specification and implementation, in order to enable users to come up with better size estimates at early stages of the software development cycle. Through a statistical approach the method also provides a confidence interval for the derived size estimates. The relation between the presented software sizing model and project cost estimation has also been considered. [ABSTRACT FROM AUTHOR]

The programming tradeoffs between structure-oriented and clause-oriented operations on data structures in Prolog are limited in current implementations of Prolog, because the assertion of clauses that include uninstantiated variables destroys any binding between these variables and those with which they are unified in the execution of the program. In this paper, we propose new built-in predicates for Prolog that allow us to assert predicate variable pointers, which are constants, rather than uninstantiated variables. We show: 1) the possible performance benefits of clause-oriented implementations of data structures over equivalent structure-oriented versions, 2) the logical implications of the proposed built-in predicates, and 3) their practical significance by integrating them in C-Prolog, and evaluating the two different implementations of the symbol table dictionary in Warren's Pseudo-Pascal Compiler example. [ABSTRACT FROM AUTHOR]

This paper describes a computer-aided software development process design. This is a computerized intelligent tool designed to aid managers of software development projects in planning, managing, and controlling the development process of medium to large scale software projects. The application of this computerized tool should help reduce the uncertainties involved in the budget, personnel, and schedule planning of software development projects. A dynamic model for the software development and maintenance life cycle process is described here. This dynamic process is composed of a number of time-varying, interacting developmental phases. Each developmental phase is characterized both by its intended functions and by the requirements for personnel, budget, and schedules. System dynamics is used to model and simulate the dynamic process of soft- ware development. The model is implemented as the software life cycle simulator (SLICS). [ABSTRACT FROM AUTHOR]

Creating and enhancing a software engineering work force requires several different types of continuing education for software professionals, including: task-oriented education, enhancement-oriented education and selection-oriented education. In this paper, we focus on the important, but often neglected, category of selection-oriented education. We begin with a discussion of technology selection, indicating what it involves, how it contributes to improving the state of practice, and why it is key to technology improvement in general. This is followed by a discussion of some criteria for selection-oriented education programs. We then describe the selection-oriented education activities at the Rocky Mountain Institute of Software Engineering and relate some problems encountered in establishing these activities. [ABSTRACT FROM AUTHOR]

This paper presents an approach to meeting the academic objectives of advanced software engineering project courses. The objectives are increased competence and confidence of the students in carrying out software development projects. The academic context includes a simulated industrial context. Part of the industrial context consists of industrial roles played for the student team by the instructor and others. The project itself is divided into tasks related to deliverables and collateral responsibilities. The software production model is a combination of the waterfall, iterative enhancement, and document-driven techniques. A software development environment is mentioned although the details are presented elsewhere. Further detail is given for five project courses conducted by the author. [ABSTRACT FROM AUTHOR]

The "software hut" is a course project that is used in conjunction with a graduate-level course in software engineering. The purpose of this project is to give the students some "real world" experience with the design and implementation of software. This paper describes the author's experience in using such a project and presents some suggestions on how a project should be organized. [ABSTRACT FROM AUTHOR]

Israel Aircraft Industries has developed a comprehensive educational program in software engineering. Goals of the program include: the retraining of college graduates to become software engineers with specializations in one of three application areas (data processing, embedded computer systems, and CAD/CAM systems), and enhancement of the knowledge of currently practicing software engineers. The program is centered around three distinct full-time courses of study having an average duration of 7 months. The training pro- gram also includes a large number of short courses and seminars. The company is currently planning an M.Sc. program in embedded computer systems and software engineering in cooperation with one of the universities in Israel. This paper describes the needs leading to the development of such an extensive program, the objectives and the structure of the various courses, the students, the training center staff, the educational computer laboratories, and the lessons learned. [ABSTRACT FROM AUTHOR]

This paper describes an approach to teaching a software design methodology used at The Wang Institute of Graduate Studies. The approach is general enough to be used with any of the currently popular design methodologies. Students are first taught the principles underlying the methodology, and the standards used with it. This phase is done in a series of lectures. In the second phase, students are presented with a real design problem, and asked to solve it using the methodology. They are monitored in this process by an expert in the methodology whose job is to assure that the students adhere to the methodology, but who makes no design decisions. The first phase has been used several times at The Wang Institute both as part of a core course in the regular MSE curriculum and as a one-week summer institute course. The second phase has been implemented once as a project course and once as a one-week summer institute course. [ABSTRACT FROM AUTHOR]

Typical software engineering courses teach principles in lectures and readings, then apply them in the development of a single program (requiring several months). We recently taught a software engineering class that incorporated many smaller exercises (requiring several hours). The class was successful: students were able to experiment with a broad set of ideas, and make interesting mistakes without jeopardizing the grades of their development team. This paper describes some tools and techniques we taught, and suggests how they might be incorporated into typical software engineering classes. [ABSTRACT FROM AUTHOR]

This paper describes a computerized environment, SODOS (Software Documentation Support), which supports the definition and manipulation of documents used in developing software. An object oriented environment is used as a basis for the SODOS interface. SODOS is built around a Software Life Cycle (SLC) Model that structures all access to the documents stored in the environment. One advantage of this model is that it supports software documentation independent of any fixed methodology that the developers may be using. The main advantage of the system is that it permits traceability through each phase of the Life Cycle, thus facilitating the test and maintenance phases. Finally the effort involved in learning and using SODOS is simplified due to a sophisticated "user-friendly" interface. [ABSTRACT FROM AUTHOR]

A real-time system must be reliable if a failure to meet its timing specifications might endanger human life, damage equipment, or waste expensive resources. Applications that require remote operation, timing accuracy, and long periods of activity need mechanisms to support reliability. Fault tolerance improves reliability by incorporating redundancy into the system design. A deadline mechanism has been proposed to provide fault tolerance in real-time software systems. The mechanism trades the accuracy of the results of a service for timing precision. Two independent algorithms are provided for each service subject to a deadline. The primary algorithm produces a good quality service, although its real-time reliability may not be assured. The alternate algorithm is reliable and produces an acceptable response. This paper introduces an algorithm to generate an optimal schedule for the deadline mechanism and discusses a simple and efficient implementation. The schedule ensures the timely completion of the alternate algorithm despite a failure to complete the primary algorithm within real time. [ABSTRACT FROM AUTHOR]

Network transparency refers to the ability of a distributed system to hide machine boundaries from people and application programs; i.e., all resources are accessed in the same manner, independent of their locations. Network transparency has been shown to be highly valuable and achievable in the local area network environment. In contrast, access to remote resources in a long haul or wide area network traditionally is not transparent; substantially different access methods are required and only a limited set of operations is available. In this paper, we demonstrate that transparency across a long haul network is both highly desirable and technically feasible. A case study of the transparent, distributed operating system Locus, extended to operate transparently across an internet system that includes long haul links, is discussed at length. New protocols, distributed cache management, and process execution site selection are all used to achieve the results reported. [ABSTRACT FROM AUTHOR]

This paper addresses the problem of assigning the modules of a distributed program to the processors of a distributed system. The goal of such an assignment is to minimize the total execution and communication costs. A computational model of a distributed program, containing probabilistic branches and loops, is described using a directed graph whose edges represent precedence relations between modules. Efficient algorithms based on shortest path methods are presented to determine the optimum assignment on a distributed system containing N heterogeneous processors. [ABSTRACT FROM AUTHOR]

Gutenberg is a port-based operating system being designed to study protection issues in distributed systems. In the Gutenberg system, all shared resources are viewed as protected objects and hence can be accessed only via specific operations defined on them. Processes communicate and access objects through the use of ports. Each port is associated with an abstract data type operation and can be created by a process only if the process has the capability to execute the operation on the type. Thus, a port represents the privilege of the port's client process to request a service (an abstract data type operation) provided by the port's server process (the type's manager). Capabilities to create ports for requesting operations are contained in a capability directory, which is navigated by processes to gain these capabilities. Privilege transfer is a means of providing servers access to the resources they need to perform their services. In Gutenberg, privilege transfer is accomplished by allowing access to subdirectories of the capability directory and by passing capabilities, including port access capabilities, to processes via ports. It should be possible to revoke transferred privileges when breaches of trust are detected or suspected, when a period of time has passed beyond which the distributor of a privilege does not want the privilege shared, or when an error has been detected. Transfer and revocation of privileges in Gutenberg is the subject of this paper. In particular, we describe the types of privileges in Gutenberg, discuss the mechanisms provided for the transfer and revocation of different types of privileges, and sketch the means for handling exceptions during privilege transfer. [ABSTRACT FROM AUTHOR]

Experimentation in software engineering supports the advancement of the field through an iterative learning process. In this paper we present a framework for analyzing most of the experimental work performed in software engineering over the past several years. We describe a variety of experiments in the framework and discuss their contribution to the software engineering discipline. Some useful recommendations for the application of the experimental process in software engineering are included. [ABSTRACT FROM AUTHOR]

The development of correct specifications is a critical task in the software development process. This paper describes an alternative approach for the development of specifications. The approach relies on a specification language for abstract data types and a synthesis system. The system is capable of translating an abstract data type specification into an executable program. This process defines an alternative methodology that provides the necessary tools for the early testing of the specifications and for the development of prototypes and implementation models. [ABSTRACT FROM AUTHOR]

Over the last decade there has developed an acute awareness of the need to introduce abstraction and mathematical rigor into the programming process. This increased formality allows for the automatic manipulation of software, increasing productivity, and, even more importantly, the manageability of complex systems. Along these lines, attribute grammars constitute a formal mechanism for specifying translations between languages; from a formal description of the translation a translator can be automatically constructed. In this paper we consider taking this process one step further: given an attribute grammar specifying the translation from language L1 to language L2, we address the question of whether the inverse attribute grammar specifying the inverse translation from L2 to L1 can be automatically generated. We show how to solve this problem for a restricted subset of attribute grammars. This inversion process allows for compatible two-way translators to be generated from a single description. To show the practical feasibility of attribute grammar inversion, we relate our experience in inverting an attribute grammar used as an interface for a formal database accessing language, SQL. The attribute grammar is used to paraphrase SQL database queries in English. [ABSTRACT FROM AUTHOR]

In most current locally distributed systems, the work generated at a node is processed there; little sharing of computational resources is provided. In such systems it is possible for some nodes to be heavily loaded while others are lightly loaded, resulting in poor overall system performance. The purpose of load sharing is to improve performance by redistributing the workload among the nodes. The load sharing policies with the greatest potential benefit are adaptive in the sense that they react to changes in the system state. Adaptive policies can range from simple to complex in their acquisition and use of system state information. The potential advantage of a complex policy is the possibility that such a scheme can take full advantage of the processing power of the system. The potential disadvantages are the overhead cost, and the possibility that a highly tuned policy will behave in an unpredictable manner in the face of the inaccurate information with which it inevitably will be confronted. The goal of this paper is not to propose a specific load sharing policy for implementation, but rather to address the more fundamental question of the appropriate level of complexity for load sharing policies. We show that extremely simple adaptive load sharing policies, which collect very small amounts of system state information and which use this information in very simple ways, yield dramatic performance improvements. These policies in fact yield performance close to that expected from more complex policies whose viability is questionable. We conclude that simple policies offer the greatest promise in practice, because of their combination of nearly optimal performance and inherent stability. [ABSTRACT FROM AUTHOR]

As the social demand on database utilization expands, database systems are being directly handled more and more by non- professionals. In this field, it is important that friendly user-interfaces are provided. It has been found that nonprocedural ways of describing queries such as QRE are preferred. A further step toward attaining a higher degree of user-friendliness would be the development of a way of enabling the system to perform a flexible interpretation of queries usually specified definitely by the user. A flexible interpretation is necessary so that data items which are semantically close to an exact match with the query conditions can be obtained. This paper presents a relational database system, ARES, which has the capability of performing a flexible interpretation of queries. In ARES, relational operations have been functionally augmented with an additional comparison operator which implies "approximately equal to" or "similar to" for cases in which the user expects the system to perform a flexible interpretation of the query conditions. The functional augmentation is simply achieved by a combination of conventional relational operations. ARES is now in actual operation in a research environment, and will contribute to the next step of our research toward implementation of highly intelligent data processing facilities beyond the present scope of database technology. [ABSTRACT FROM AUTHOR]

Decentralized consensus protocols are characterized by successive rounds of message interchanges. Protocols which achieve a consensus in one round of message interchange require O(N²) messages, where N is the number of participants. In this paper, we present a communication scheme, based on finite projective planes, which requires only O(N√N) messages for each round. Using this communication scheme, we develop decentralized consensus protocols which achieve a consensus within two rounds of message interchange. The protocols are symmetric, and the communication scheme does not impose any hierarchical structure. We illustrate our scheme using blocking and nonblocking commit protocols, decentralized extrema finding, and computation of the sum function. [ABSTRACT FROM AUTHOR]

Program structure is designed, redesigned, and develops and changes during the development phase. This paper describes a mini methodology for generation and representation of design and program structures, and structural consistency checking between two successive designs or between a design and a program. The mini methodology is based on the following. 1) The tool: a special Program Design Language (PDL) which is equipped to extract the actual and complete structure information from design documents and programs, or partial structure information—when required. 2) The representation: two matrices, a Call Relationship Matrix (CRM) and a Global References Matrix (GRM), which completely rep- resent the program structure. 3) The consistency criteria: clear definitions when the structures of two successive designs, or a design and a program, are consistent. The PDL extracts structure information, in a controlled way, from the top level program design, through layers of detailed designs, down to the source code itself. It generates an actual, complete, concise, and easily comparable structure representation. Structural consistency between levels can be checked, both at the development phase and at the operation and maintenance phase, ensuring continued structural consistency between the design(s) and the program. The structure representation can also be used for configuration management of the structure of designs and programs. [ABSTRACT FROM AUTHOR]

We present a practical extension to typestate checking which is capable of proving programs free of uninitialized variable errors even when these programs contain conditionally initialized variables where the initialization of a variable depends upon the equality of one or more "tag" variables to a constant. The user need not predeclare the relationship between a conditionally initialized variable and its tags, and this relationship may change from one point in the program to another. Our technique generalizes liveness analysis to conditional liveness analysis. Like typestate checking, our technique incorporates a dataflow analysis algorithm in which each point in a program is labeled with a lattice point describing statically tracked information, including the initialization of variables. The labeling is then used to check for programming errors such as referencing a variable which may be uninitialized. Our technique incorporates a more expressive lattice, including predicates of the form: "x is initialized if y equals 2." Because the number of tags per variable is small, the added complexity of the analysis is usually small. The efficiency of our technique is due, to a large extent, to the fact that we use a backwards analysis of the program (instead of the forward analysis used in the original typestate checking algorithm). Our results suggest that backwards analysis—tracking only those properties which need to hold to make the subsequent statements correct—can be more efficient than forward analysis—tracking all properties which are made true by the preceding statements. We conclude with some additional applications of our techniques to program checking. [ABSTRACT FROM AUTHOR]

A methodology is presented for evaluating the performance of database update schemes in a distributive environment. The methodology makes use of the history of how data are used in the database. Parameters, such as update to retrieval ratio and average file size, can be set based on the actual characteristics of a system. The analysis is specifically directed toward the support of derived data within the relational model. Because concurrency is a major problem in a distributive system, the support of derived data is analyzed with respect to three distributive concurrency control techniques—master/slave, distributed, and synchronized. [ABSTRACT FROM AUTHOR]

This article presents information about the selection of the four best papers submitted to the 27th International Conference on Software Engineering held on May 21, 2005. A summary for each paper is provided along with the author's name and the main topic of each paper. One paper deals with a new approach to software fault tolerance. Another paper discusses an environment for finding and visualizing examples of usage of an API. The third paper reports on a study to determine the limitations of tools used in computer maintenance tasks.

This article presents information on articles published in September 1999 issue of the journal "IEEE Transactions on Software Engineering." Computer systems are used to perform many critical tasks, including guiding aircraft, scheduling railroads, assisting in surgery, controlling nuclear reactors, performing financial transactions and supporting military command and control. Although the study of these properties evolved as separate disciples, they have in common the fact that a user must have a high degree of confidence in the service that the system delivers. The first research paper in this issue of the journal considers the problem of electing a leader in a distributed system that may become partitioned. Since the partitions will not be able to communicate with each other, it is necessary to elect a leader for each partition. The second research paper addresses the problem of developing an accurate fault model that can be used to evaluate the dependability of a system. The third paper presents an approach to the quantitative evaluation of the security of operational systems.

Comments on the articles in the "IEEE Transactions on Software Engineering" were given. The periodical has an established, published scope which is subject to change as the file develops. Part of the review process is to state whether the paper meets the criteria. The scope should be limited to papers of interest to the software engineering community. However, besides mainstream software engineering topics, it could include the software engineering of various applications.

This article reports that several changes in the periodical "IEEE Transactions on Software Engineering," published as of February 01, 2004, will make the processing of articles more timely and more effective. First, the length restriction on submitted manuscripts has been removed. This should allow authors to document results in appropriate length papers. Despite the change, authors are encouraged to keep papers as short as possible. Second, Transactions on Software Engineering manuscript management has been moved to the Web-based Manuscript Central system. This system makes all aspects of manuscript processing much more efficient and it allows everybody involved in processing papers, including authors, to obtain details of the state of manuscripts as they are processed. Third, preprints in the future will be available online two months before the issue cover date. Software remains a critical industry to the world. The impact of software is tremendous, both when it works and when it doesn't.

This editorial explains why the issues of "IEEE Transactions on Software Engineering" are late in going to subscribers. There have been problems with the printing process because the IEEE Publishing Services has made changes in its operations but steps have been taken to remedy the problem. A system has been instituted to allow authors to get information about the status of their submitted papers. The biggest problem in responding to authors quickly is getting reviews back from reviewers is that some reviewers do return the papers for months. Some of the fault lies with reviewers and some with authors who submit papers that are difficult to review. Suggestions for authors are hereby presented in order to expedite the handling of papers.

For a contribution for the journal "IEEE Transactions on Software Engineering" to be acceptable for publication as a regular paper, it must comprise novel material not previously published in a technical journal. The novelty will usually lie in original results, methods, observations, concepts or applications, but may also reside in synthesis of or new insights into previously reported research. In 1991, the journal will publish four special sections. The journal currently received about 28 papers per month, not counting special issue papers. Upon receipt of a paper, the editor's goal is to have the acknowledgment letter to the author and the paper to the editor within seven days. The past and present editors of the journal was listed.

This editorial addresses various issues relating to the periodical "IEEE Transactions on Software Engineering." It outlines the process by which papers are received and reviewed for publication. It encourages authors to submit electronic copies of their papers to facilitate editing. Lastly, it puts forth the requirements for papers submitted for general and special issues.

There will be a rotation of editors of the periodical "IEEE Transactions on Software Engineering." The periodical is receiving about 25 papers a month, not counting special issue papers. Upon receipt of a paper, the goal is to have the acknowledgment letter to the author and the paper to the editor within five working days.

It its the eleventh year of "Transactions on Software Engineering" periodical. There is a need for survey papers. The periodical is soliciting in-depth survey papers in the emerging research areas in software engineering. Student papers are also solicited. The members of the editorial board are listed.

Presents a letter to the editor concerning the article "Protocol Conversion".

There are beliefs shared with respect to the distribution of technical information on software. The first is that the increase of the container that not increase, but at most inflates, the content: beyond a certain point more pages available for publication. The polarization of software engineering into the two subcultures of theoreticians and practitioners is at least as much present now.

This guest editorial introduces the topic of requirements engineering which is to be the focus of the March 1991 issue of the periodical "IEEE Transactions on Software Engineering." The technical area of software engineering called requirements engineering encompasses a broad set of problems and alternative approaches. To help readers understand how the papers included in the issue relate to each other and to requirements engineering, a brief partial taxonomy is presented.

Shankar and Lam propose a projection method for protocol verification. They claim that the method guarantees the faithfulness of the safety and liveness properties of a protocol system. Although not clearly defined, "faithfulness" (as implied in many places in their article) means "the image protocol system is live (respectively, safe) if and only if the original protocol system is live (respectively, safe)." This paper shows that the "only if" part is not true for certain liveness properties and suggests a remedy. [ABSTRACT FROM AUTHOR]

Framework-specific modeling languages (FSMLs) help developers build applications based on object-oriented frameworks. FSMLs model abstractions and rules of application programming interfaces (APIs) exposed by frameworks and can express models of how applications use APIs. Such models aid developers in understanding, creating, and evolving application code. We present four exemplar FSMLs and a method for engineering new FSMLs. The method was created postmortem by generalizing the experience of building the exemplars and by specializing existing approaches to domain analysis, software development, and quality evaluation of models and languages. The method is driven by the use cases that the FSML under development should support and the evaluation of the constructed FSML is guided by two existing quality frameworks. The method description provides concrete examples for the engineering steps, outcomes, and challenges. It also provides strategies for making engineering decisions. Our work offers a concrete example of software language engineering and its benefits. FSMLs capture existing domain knowledge in language form and support application code understanding through reverse engineering, application code creation through forward engineering, and application code evolution through round-trip engineering. [ABSTRACT FROM AUTHOR]

The scientific study of a phenomenon requires it to be reproducible. Mature engineering industries are recognized by projects and products that are, to some extent, reproducible. Yet, reproducibility in software engineering (SE) has not been investigated thoroughly, despite the fact that lack of reproducibility has both practical and scientific consequences. We report a longitudinal multiple-case study of variations and reproducibility in software development, from bidding to deployment, on the basis of the same requirement specification. In a call for tender to 81 companies, 35 responded. Four of them developed the system independently. The firm price, planned schedule, and planned development process, had, respectively, "low," "low," and "medium" reproducibilities. The contractor's costs, actual lead time, and schedule overrun of the projects had, respectively, "medium," "high," and "low" reproducibilities. The quality dimensions of the delivered products, reliability, usability, and maintainability had, respectively, "low," "high," and "low" reproducibilities. Moreover, variability for predictable reasons is also included in the notion of reproducibility. We found that the observed outcome of the four development projects matched our expectations, which were formulated partially on the basis of SE folklore. Nevertheless, achieving more reproducibility in SE remains a great challenge for SE research, education, and industry. [ABSTRACT FROM AUTHOR]