Search

The International Computer and Software Applications Conference has celebrated its tenth anniversary in 1986. The conference has been very successful in attracting excellent papers and panels from both academia and industry. It continued the tradition and attracted superb papers for the following tracks: software quality, software engineering, software requirements, development environments, software techniques and knowledge-based systems.

The interpretations of logical expressions found in most introductory textbooks are not suitable for use in software engineering applications because they do not deal with partial functions. More advanced papers and texts deal with partial functions in a variety of complex ways. This paper proposes a very simple change to the classic interpretation of predicate expressions, one that defines their value for all values of all variables, yet is almost identical to the standard definitions. It then illustrates the application of this interpretation in software documentation. [ABSTRACT FROM AUTHOR]

Recently, significant progress has been made in the development of physics-based, knowledge-aided (KA) signal processing strategies supported by improvements in real-time embedded computing architectures. These developments provide designers of advanced sensor systems an unprecedented degree of flexibility when implementing next generation adaptive sensor systems. In the case of radar, this has been manifested in the first ever, real-time, KA space-time adaptive processing (KA-STAP) system for advanced clutter/interference suppression. This paper provides exemplars of real-world effects giving rise to the need for "intelligent" adaptation schemes and overviews the KA approach to sensor signal processing in some detail. Moreover, we survey a collection of papers describing recent KA sensor research that follow in this issue. [ABSTRACT FROM AUTHOR]

For the development of communications software com- posed of many modules, protocol validation is essential to detect errors in the interactions among the modules. A number of protocol validation techniques were proposed in the past, but the validation time required by these techniques is too long for many actual protocols. This paper proposes a new fast protocol validation technique to overcome this drawback. The proposed technique is to construct the minimum acyclic form of state transitions in individual processes of the protocol, and to detect protocol errors such as system deadlocks and channel overflows fast. This paper also presents a protocol validation system based on the proposed technique to confirm its feasibility and shows validation results for some actual protocols obtained with this system. As a result, the protocol validation system is expected to contribute to a great extent to the improvement of the productivity in development and maintenance of communications software. [ABSTRACT FROM AUTHOR]

This special issue focuses on elucidating computational neuroscience: an interdisciplinary field of scientific research in which one of the primary goals is to understand how electronic activity in brain cells and networks enables biological intelligence. The objective is to provide a selection of papers that expose and review research efforts in aspects of computational neuroscience that demonstrate its rapidly growing intersection with electrical, electronic and computer engineering, and the prospects for interaction in the near and long-term future. [ABSTRACT FROM PUBLISHER]

Context: Variability (i.e., the ability of software systems or artifacts to be adjusted for different contexts) became a key property of many systems. Objective: We analyze existing research on variability in software systems. We investigate variability handling in major software engineering phases (e.g., requirements engineering, architecting). Method: We performed a systematic literature review. A manual search covered 13 premium software engineering journals and 18 premium conferences, resulting in 15,430 papers searched and 196 papers considered for analysis. To improve reliability and to increase reproducibility, we complemented the manual search with a targeted automated search. Results: Software quality attributes have not received much attention in the context of variability. Variability is studied in all software engineering phases, but testing is underrepresented. Data to motivate the applicability of current approaches are often insufficient; research designs are vaguely described. Conclusions: Based on our findings we propose dimensions of variability in software engineering. This empirically grounded classification provides a step towards a unifying, integrated perspective of variability in software systems, spanning across disparate or loosely coupled research themes in the software engineering community. Finally, we provide recommendations to bridge the gap between research and practice and point to opportunities for future research. [ABSTRACT FROM PUBLISHER]

An operating system course draws from a well-defined fundamental theory, but one needs to consider how more re- cent advances, not necessarily in the theory itself, can be applied to improve the course and the general body of knowledge of the student. The goal of this paper is to show how recent software engineering developments can be introduced to such a course to not only satisfy the theory requirements, but also make the theory more understandable. In particular, this paper focuses on how students can effectively learn the Unified Modeling Language, the object-oriented methodology, and the Java programming language in the context of an operating systems course. The goal is to form a systematic software engineering process for operating system design and implementation. [ABSTRACT FROM AUTHOR]

Current control in inverter-driven machine systems is the inner most component of the hierarchy of control loops. If the control of current in the machine is not fast and accurate then it is difficult, if not impossible, to build a high-performance drive system. Unfortunately, the implementation of current control in power electronic systems is not ideal. Practical effects can have a significant influence on its performance. This paper examines one of these effects, dead time, and considers the influence it has on the performance of predictive current controllers (PCCs). The paper presents analysis that shows that a PCC implicitly compensates for voltage loss due to dead time. Also, a modified PCC is introduced that reduces the zero-current-clamp problem caused by dead time. Simulation and experimental results are presented to verify the analysis and confirm the performance of the new algorithm. [ABSTRACT FROM AUTHOR]

Requirements engineering is concerned with the elicitation of high-level goals to be achieved by the envisioned system, the refinement of such goals and their operationalization into specifications of services and constraints and the assignment of responsibilities for the resulting requirements to agents such as humans, devices, and software. Requirements engineering processes often result in goals, requirements, and assumptions about agent behavior that are too ideal; some of them are likely not to be satisfied from time to time in the running system due to unexpected agent behavior. The lack of anticipation of exceptional behaviors results in unrealistic, unachievable, and/or incomplete requirements. As a consequence, the software developed from those requirements will not be robust enough and will inevitably result in poor performance or failures, sometimes with critical consequences on the environment. This paper presents formal techniques for reasoning about obstacles to the satisfaction of goals, requirements, and assumptions elaborated in the requirements engineering process. A first set of techniques allows obstacles to be generated systematically from goal formulations and domain properties. A second set of techniques allows resolutions to be generated once the obstacles have been identified thereby. Our techniques are based on a temporal logic formalization of goals and domain properties; they are integrated into an existing method for goal-oriented requirements elaboration with the aim of deriving more realistic, complete, and robust requirements specifications. A key principle in this paper is to handle exceptions at requirements engineering time and at the goal level, so that more freedom is left for resolving them in a satisfactory way. The various techniques proposed are illustrated and assessed in the context of a real safety-critical system. [ABSTRACT FROM AUTHOR]

Opto-electronic components and their performances are well suited to be integrated in radar systems. In this paper, two optical architectures illustrate functions that are specific to optical processing of microwave signals, i.e., time-delay-based processing and arbitrary waveform generation of large frequency bandwidth signals. [ABSTRACT FROM AUTHOR]

In this paper, a scheme for estimating the proportion of the incoming traffic that is not responsive to congestion at a router is presented. The idea of the proposed scheme is that if the observed queue length and packet drop probability do not match the predictions from a model of responsive (TCP) traffic, then the error must come from nonresponsive traffic; it can then be used for estimating the proportion of nonresponsive traffic. The pro- posed scheme is based on the queue length history, packet drop history, and expected TCP and queue dynamics. The effectiveness of the proposed scheme over a wide range of traffic scenarios is corroborated using ns-2-based simulations. Potential applications of the proposed algorithms in traffic engineering and control are discussed. [ABSTRACT FROM AUTHOR]

Feedback signaling plays a key role in flow control because the traffic source relies on the signaling information to make correct and timely flow-control decisions. However, it is difficult to design an efficient signaling algorithm since a signaling message can tolerate neither error nor latency. Multicast flow-control signaling imposes two additional challenges: scalability and feedback synchronization. Previous research on multicast signaling has mainly focused on the development of algorithms without analyzing their delay performance. To remedy this deficiency, we have previously developed a binary-tree model and an independent-marking statistical model for multicast-signaling delay analysis. This paper considers a general scenario where the congestion markings at different links are dependent—a more accurate but complex case. Specifically, we develop a Markov-chain model defined by the link-marking state on each path in the multicast tree. The Markov chain can not only capture link-marking dependencies, but also yield a tractable analytical model. We also develop a Markov-chain dependency-degree model to evaluate all possible Markov-chain dependency degrees without any prior knowledge of them. Using the above two models, we derive the general probability distributions of each path becoming the multicast-tree bottleneck. Also derived are the first and second moments of multicast signaling delays. The proposed Markov chain is also shown to asymptotically reach an equilibrium, and its limiting distribution converges to the marginal link-marking probabilities when the Markov chain is irreducible. Applying the two models, we analyze and contrast the delay scalability of two representative multicast signaling protocols: Soft-Synchronization Protocol (SSP) and Hop-By-Hop (HBH) algorithms. [ABSTRACT FROM AUTHOR]

In this paper, we address the issue of pruning (i.e., shortening) a given interleaver in a parallel concatenated convolutional code (PCCC). The principle goal of pruning is that of construction of variable-length and hence delay interleavers with application to PCCC, using the same structure (possibly in hard- ware) of the interleaver and deinterleaver units. As a side benefit, it is sometimes possible to reduce the interleaver length and hence delay for nearly the same and sometimes even better asymptotic performance. In particular, we present a systematic technique for interleaver pruning and demonstrate the average optimality of the strategy. Sample simulation results are presented confirming the average optimality of the proposed scheme. [ABSTRACT FROM AUTHOR]

Many previous works on floorplanning with non rectangular modules [1]-[12] assume that the modules are predesignated to have particular non rectangular shapes, e.g., L-shaped, T-shaped, etc. However, this is not common in practice because rectangular shapes are more preferable in many designing steps. Those non rectangular shapes are actually generated during floor planning in order to further optimize the solution. In this paper, we study this problem of changing the shapes and dimensions of the flexible modules to fill up the unused area of a preliminary floor plan, while keeping the relative positions between the modules unchanged. This feature will also be useful in fixing small incremental changes during engineering change order modifications. We formulate the problem as a mathematical program. The formulation is such that the dimensions of all of the rectangular and, nonrectangular modules can be computed by closed-form equations in O(m) time in each corresponding Lagrangian relaxation sub problem (LRS) where m is the total number of edges in the constraint graphs. As a result, the total time for the whole shaping and sizing process is O(k × m), where k is the number of iterations on the LRS. Experimental results show that the amount of area reused is 3.7% on average, while the total wirelength can be reduced by 0.43% on average because of the more compacted result packing. [ABSTRACT FROM AUTHOR]

With growing interest in distributed computing come demands for techniques to aid in development of correct and reliable distributed software. Controlling, or at least recognizing, complexity of such software is an important part of the development and maintenance process. While a number of metrics have been proposed for quantitatively measuring the complexity of sequential, centralized programs, corresponding metrics for distributed software are noticeable by their absence. Using Ada as a representative distributed programming language, this paper discusses some ideas on complexity metrics that focus on Ada tasking and rendezvous. Concurrently active rendezvous are claimed to be an important aspect of communication complexity. A Petri net graph model of Ada rendezvous is used to introduce a "rendezvous graph," an abstraction that can be useful in viewing and computing effective communication complexity. [ABSTRACT FROM AUTHOR]

In spite of their advantage in removing the overhead of lock maintenance and deadlock handling, optimistic concurrency control methods have continued to be far less popular in practice than locking schemes. There are two complementary approaches to help render the optimistic approach practically viable. For the high-level approach, integration schemes can be utilized so that the database management system is provided with a variety of synchronization methods each of which can be applied to the appropriate class of transactions. The low-level approach seeks to increase the concurrency of the original optimistic method and improve its performance. In this paper we examine the latter approach, and present algorithms that aim at reducing backups and improve throughput. Both the single-site and distributed networks are considered. Optimistic schemes using time-stamps for fully duplicated and partially duplicated database networks are presented, with emphasis on performance enhancement and on reducing the overall cost of implementation. Abstract-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]

The formalism of temporal logic has been suggested to be an appropriate tool for expressing the semantics of concurrent programs. This paper is concerned with the application of temporal logic to the specification of factors affecting the synchronization of concurrent processes. Towards this end, we first introduce a model for synchronization and axiomatize its behavior. SYSL, a very high-level language for specifying synchronization properties, is then described. It is designed using the primitives of temporal logic and features constructs to express properties that affect synchronization in a fairly natural and modular fashion. Since the statements in the language have intuitive interpretations, specifications are humanly readable. In addition, since they possess appropriate formal semantics, unambiguous specifications result. [ABSTRACT FROM AUTHOR]

This paper discusses the goals and methods of the Toolpack project and in this context discusses the architecture and design of the software system being produced as the focus of the project. Toolpack is presented as an experimental activity in which a large software tool environment is being created for the purpose of general distribution and then careful study and analysis. The paper begins by explaining the motivation for building integrated tool sets. It then proceeds to explain the basic requirements that an integrated system of tools must satisfy in order to be successful and to remain useful both in practice and as an experimental object. The paper then summarizes the tool capabilities that will be incorporated into the environment. It then goes on to present a careful description of the actual architecture of the Toolpack integrated tool system. Finally the Toolpack project experimental plan is presented, and future plans and directions are summarized. [ABSTRACT FROM AUTHOR]

Measurement of water level and conductivity is important in many applications, including geophysics, ocean engineering, and the oil industry, with one example being gas/oil/water separation. Noncontact measurement is ideal for those applications. Capacitance, radar, ultrasonic, and laser techniques have been used in measuring the level, but simultaneous measurements of level and conductivity have not been reported. In this paper, we developed a novel inductive sensor, which uses two coils of different sizes to simultaneously infer conductivity and level based on a simplified model deduced from an analytical solution. The simplified model is verified with both simulation and experimental data. The experimental results have shown that the measurement accuracy for both level and conductivity is within 3%. [ABSTRACT FROM AUTHOR]

Many modern software systems are designed to be highly configurable so they can run on and be optimized for a wide variety of platforms and usage scenarios. Testing such systems is difficult because, in effect, you are testing a multitude of systems, not just one. Moreover, bugs can and do appear in some configurations, but not in others. Our research focuses on a subset of these bugs that are "option-related"--those that manifest with high probability only when specific configuration options take on specific settings. Our goal is not only to detect these bugs, but also to automatically characterize the configuration subspaces (i.e., the options and their settings) in which they manifest. To improve efficiency, our process tests only a sample of the configuration space, which we obtain from mathematical objects called covering arrays. This paper compares two different kinds of covering arrays for this purpose and assesses the effect of sampling strategy on fault characterization accuracy. Our results strongly suggest that sampling via covering arrays allows us to characterize option-related failures nearly as well as if we had tested exhaustively, but at a much lower cost. We also provide guidelines for using our approach in practice. [ABSTRACT FROM AUTHOR]

This paper describes the rationale and the content of a two-semester four-hour-per-week course titled Telecommunication Systems. The course covers telecommunications in an overall manner, avoiding the segmentation of the telecommunications subject and introducing the student to the theoretical and engineering aspects of telecommunications in the shortest time possible. The course consists of six consecutive modules (basics, signals and systems, transmission techniques, telecommunication links, networks and services, and market issues). Besides offering background telecommunication knowledge and providing the student with a clear and well-structured overview of the overall telecommunications subject, it aims at introducing the student to the basic methodology for treating practical engineering problems. [ABSTRACT FROM AUTHOR]

The growing demand of computer usage requires efficient ways of managing network traffic in order to avoid or at least limit the level of congestion in cases where increases in bandwidth are not desirable or possible. In this paper we developed and analyzed a generic Integrated Dynamic Congestion Control (IDCC) scheme for controlling traffic using information on the status of each queue in the network. The IDCC scheme is designed using nonlinear control theory based on a nonlinear model of the network that is generated using fluid flow considerations. The methodology used is general and independent of technology, as for example TCP/IP or ATM. We assume a differentiated-services network framework and formulate our control strategy in the same spirit as IP DiffServ for three types of services: Premium Service, Ordinary Service, and Best Effort Service. The three differentiated classes of traffic operate at each output port of a router/switch. An IDCC scheme is designed for each output port, and a simple to implement nonlinear controller, with proven performance, is designed and analyzed. Using analysis performance bounds are derived for provable controlled network behavior, as dictated by reference values of the desired or acceptable length of the associated queues. By tightly controlling each output port, the overall network performance is also expected to be tightly controlled. The IDCC methodology has been applied to an ATM network. We use OPNET simulations to demonstrate that the proposed control methodology achieves the desired behavior of the network, and possesses important attributes, as e.g., stable and robust behavior, high utilization with bounded delay and loss, together with good steady-state and transient behavior. [ABSTRACT FROM AUTHOR]

This paper presents digital noise in signal integrity and clarifies noise margin issues in digital electronics education. For the static noise margin, the traditional definition violates the basic principle of noise. The embedded rectangle method to define the static noise margin is a more reliable criterion. For the dynamic noise margin (DNM), several approaches have been evaluated. The best way to teach the student DNM is suggested. [ABSTRACT FROM AUTHOR]

One of the major problems faced in operating large networks is the enormous amount of processing and communications overhead required for setting up and tearing down the large number of connections maintained by the network. ATM and MPLS aim at solving these problems via the Virtual Path (VP) mechanism which is used to group together the connections. When a need for setting up a connection rises, the request and its resource allocation are processed by the VP agent and not by the network, thus reducing the processing cost significantly. An important question in the design of these networks is the amount of network resources to be dynamically allocated to and held by the VP agents; too high allocation will result with bandwidth resource waste, while too low allocation will result with heavy connection set-up and tear-down processing load. In this paper we deal with this problem, and at deriving simple- operational rules to determine the amount of bandwidth resources to be held by the various VP agents, while balancing between bandwidth waste and connection processing overhead. We formulate the resource allocation problem by accounting both for bandwidth utilization and for connection processing constraints. Recognizing the complexity of the problem, we use a decomposition approach in which we first analyze the single link problem and then propose to use this solution as a building block in constructing algorithms for the whole network. For the single link problem we realize that the pure problem is too complex and thus formulate an approximate model and derive the optimal allocation for it. The optimal rule is expressed as a closed-form square-root allocation. Extensive numerical examination shows that the rule proposed yields very efficient allocations. For the full network problem, we propose to capitalize on the closed form structure of the single link problem solution and use it in devising algorithms for the whole network. [ABSTRACT FROM AUTHOR]

The preemption policy currently in use in MPLS-en- abled commercial routers selects LSPs for preemption based only on their priority and holding time. This can lead to waste of resources and excessive number of rerouting decisions. In this paper, a new preemption policy is proposed and complemented with an adaptive scheme that aims to minimize rerouting. The new policy combines the three main preemption optimization criteria: number of LSPs to be preempted, priority of the LSPs, and preempted bandwidth. Weights can be configured to stress the desired criteria. The new policy is complemented by an adaptive scheme that selects lower priority LSPs that can afford to have their rate reduced. The selected LSPs will fairly reduce their rate in order to accommodate the new high-priority LSP setup request. Performance comparisons of a nonpreemptive approach, a policy currently in use by commercial routers, and our policies are also investigated. [ABSTRACT FROM AUTHOR]

Feedback delays arise in the control of a computer network—from the information transfer process itself and from the processing of control signals at the network nodes. Flow control of data sources in a computer network often results in a time-de- layed control problem. Feedback delay reduces the stability of a system. In this paper we discuss how to use the Routh-Hurwitz stability criterion to design and analyze the stability of a flow con- trol algorithm with feedback delay. [ABSTRACT FROM AUTHOR]

Deficit Round-Robin (DRR) is a scheduling algorithm devised for providing fair queueing in the presence of variable length packets. The main attractive feature of DRR is its simplicity of implementation: in fact, it can exhibit O(1) complexity, provided that specific allocation constraints are met. However, according to the original DRR implementation, meeting such constraints often implies tolerating high latency and poor fairness. In this paper, we first derive new and exact bounds for DRR latency and fairness. On the basis of these results, we then propose a novel implementation technique, called Active List Queue Method (Aliquem), which allows a remarkable gain in latency and fairness to be achieved, while still preserving O(1) complexity. We show that DRR achieves better performance metrics than those of other round-robin algorithms such as Pre-Order Deficit Round-Robin and Smoothed Round-Robin. We also show by simulation that the proposed implementation allows the average delay and the jitter to be reduced. [ABSTRACT FROM AUTHOR]

Secure multicast applications require key manage- ment that provides access control. In wireless networks, where the error rate is high and the bandwidth is limited, the design of key management schemes should place emphasis on reducing the communication burden associated with key updating. A communication-efficient class of key management schemes is those that employ a tree hierarchy. However, these tree-based key management schemes do not exploit issues related to the delivery of keying information that provide opportunities to further reduce the communication burden of rekeying. In this paper, we propose a method for designing multicast key management trees that match the network topology. The proposed key management scheme localizes the transmission of keying information and significantly reduces the communication burden of rekeying. Further, in mobile wireless applications, the issue of user handoff between base stations may cause user relocation on the key management tree. We address the problem of user handoff by proposing an efficient handoff scheme for our topology-matching key management trees. The proposed scheme also addresses the heterogeneity of the network. For multicast applications containing several thousands of users, simulations indicate a 55%–80% reduction in the communication cost compared to key trees that are independent of the network topology. Analysis and simulations also show that the communication cost of the proposed topology-matching key management tree scales better than topology-independent trees as the size of multicast group grows. [ABSTRACT FROM AUTHOR]

The User retrial phenomenon and its significant impact on network performance in unicast wireless systems are known and relatively well studied in the literature. However, there have been no previous studies on the impact of the user retrial phenomenon on other types of wireless networks. The objective of this paper is to extend the analysis of the user retrial phenomenon to wireless systems which, in addition to unicast service, also support a data broadcast service. This objective is realized by defining several performance measures appropriate for the analysis of hybrid unicast-broadcast systems in the presence of users' retrials. Subsequently, we derive the exact mathematical expression for each of the measures. Based on these expressions, we prove the existence of a single broadcast scheduling scheme, which ensures optimal system performance, with respect to the given set of proposed measures, the system's throughput, and the grade and quality of service. We also take a closer look at the class of hybrid unicast-broadcast systems with autonomous estimation of data item popularities, and we elabo- rate on the major challenges associated with such systems. Finally, we evaluate our theoretical expressions through simulation, and we discuss their robustness with respect to moderate deviations in the underlying model. [ABSTRACT FROM AUTHOR]

Although the benefits of requirements traceability are widely recognized, the actual practice of maintaining a traceability scheme is not always entirely successful. The traceability infrastructure underlying a software system tends to erode over its lifetime, as time-pressured practitioners fail to consistently maintain links and update impacted artifacts each time a change occurs, even with the support of automated systems. This paper proposes a new method of traceability based upon event-notification and is applicable even in a heterogeneous and globally distributed development environment. Traceable artifacts are no longer tightly coupled but are linked through an event service, which creates an environment in which change is handled more efficiently, and artifacts and their related links are maintained in a restorable state. The method also supports enhanced project management for the process of updating and maintaining the system artifacts. [ABSTRACT FROM AUTHOR]

Software productivity has been steadily increasing over the past 30 years, but not enough to close the gap between the demands placed on the software industry and what the state of the practice can deliver [22], [39]; nothing short of an order of magnitude increase in productivity will extricate the software industry from its perennial crisis [39], 1671. Several decades of intensive research in software engineering and artificial intelligence left few alternatives but software reuse as the (only) realistic approach to bring about the gains of productivity and quality that the software industry needs. In this paper, we discuss the implications of reuse on the production, with an emphasis on the technical challenges. Software reuse involves building software that is reusable by design and building with reusable software. Software reuse includes reusing both the products of previous software projects and the processes deployed to produce them, leading to a wide spectrum of reuse approaches, from the building blocks (reusing products) approach, on one hand, to the generative or reusable processor (reusing processes), on the other 1681. We discuss the implication of such approaches on the organization, control, and method of software development and discuss proposed models for their economic analysis. Software reuse benefits from methodologies and tools to: 1) build more readily reusable software and 2) locate, evaluate, and tailor reusable software, the last being critical for the building blocks approach. Both sets of issues are discussed in this paper, with a focus on application generators and OO development for the first and a thorough discussion of retrieval techniques for software components, component composition (or bottom-up design), and transformational systems for the second. We conclude by highlighting areas that, in our opinion, are worthy of further investigation. [ABSTRACT FROM AUTHOR]

This paper describes a new method, called mutant unification, for high-performance software testing. The method is aimed at supporting program mutation on parallel machines based on the Single Instruction Multiple Data stream (SIMD) paradigm. Several parameters that affect the performance of unification have been identified and their effect on the time to completion of a mutation test cycle and speedup has been studied. Program mutation analysis provides an effective means for determining the reliability of large software systems. It also provides a systematic method for measuring the adequacy of test data. However, it is likely that testing large software systems using mutation is computation bound and prohibitive on traditional sequential machines. Current implementations of mutation tools are unacceptably slow and are only suitable for testing relatively small programs. The unification method reported in this paper provides a practical alternative to the current approaches. It also opens up a new application domain for SIMD machines. [ABSTRACT FROM AUTHOR]

A software test data adequacy criterion is a means for determining whether a test set is sufficient, or "adequate," for testing a given program. Previous work has proposed a set of properties that useful adequacy criteria should satisfy. In this paper, we identify some additional properties of useful adequacy criteria that are appropriate under certain realistic models of testing. We then discuss modifications to the formal definitions of certain popular adequacy criteria to make the criteria consistent with these additional properties. [ABSTRACT FROM AUTHOR]

Software Performance Engineering (SPE) provides an approach to constructing systems to meet performance objectives. This paper illustrates the application of SPE to an example with some real-time properties and demonstrates how to compare performance characteristics of design alternatives. We show how SPE can be integrated with design methods and demonstrate that performance requirements can be achieved without sacrificing other desirable design qualities such as understandability, maintainability, and reusability. [ABSTRACT FROM AUTHOR]

In this paper, an integrated life-cycle model is presented for use in a software maintenance environment. This model, which represents information about the development and maintenance of software systems, emphasizing relationships between different phases of the software life cycle, provides the basis for automated tools to assist maintenance personnel in making changes to existing software systems. This model is independent of particular specification, design and programming languages because it represents only certain "basic" semantic properties of software systems: control flow, data flow, and data structure. The software development processes by which one phase of the software life cycle is derived from another are represented by graph rewriting rules, which indicate how various components of a software system have been implemented. This approach permits analysis of the basic properties of a software system throughout the soft- ware life cycle. Examples are given to illustrate the integrated software life-cycle model during evolution. [ABSTRACT FROM AUTHOR]

In examining the software science family of software complexity measures and the cyclomatic number software complexity measure, one quickly makes the following observations. There are characteristics of a program which affect its complexity and which a software science measure can detect and measure but the cyclomatic number cannot, and likewise there are characteristics which the cyclomatic number can detect and measure but the software science measures cannot. Thus, one would like to define a measure or a family of measures which are sensitive to the software characteristics measured by the software science measures and which are also sensitive to the characteristics measured by the cylomatic number. In this paper we present such a family of measures; these new measures are called weighted measures. [ABSTRACT FROM AUTHOR]

It is commonly accepted that language-oriented tools are helpful for constructing programs. In order to construct and extend language-oriented tools easily, meta-tools have been researched. Our interest is to establish a simple and flexible framework for internal representation of programs, internal representation of language-dependent information, and the behavior of language-oriented tools for user's operations. This paper presents a system for generating language-oriented editors based on the object-oriented concepts. Features of the target language are represented as classes and their relations. A program is represented as an abstract syntax tree. Each node in the tree belongs to a nodeclass. Processing of each user's operation is achieved by messages between nodes. For generating more advanced editors, probes, internal-classes, and gates are incorporated into the system. In conclusion, the system generates a flexible and easily extendable language-oriented editor from a target language description in a highly modularized fashion by using the description language which the system provides. [ABSTRACT FROM AUTHOR]

In this paper, we describe a specification model that is based on the finite state machine but is distributed. The model allows the user to decompose a large system into separate views. Each view is a complete system in itself, and reveals how the whole system would behave as seen from a certain angle. Put together, the combined views present a complete picture of the whole system. The complexity of a large centralized system is thus distributed and subdued. We then offer a simple execution scheme for our model. Using a high-level state-transition language called SXL, constructs in the model are expressed as pre- and postconditions of transitions. The execution scheme allows all the views in the model to proceed in a parallel but harmonius way, producing a working prototype for the modeled system. [ABSTRACT FROM AUTHOR]

RTAG is a language based on an attribute grammar notation for specifying protocols. Its main design goals are: 1) to support concise and easily understood expression of complex real-world protocols, and 2) to serve as the basis of a portable software system for automated protocol implementation. This paper summarizes the RTAG language, gives examples of its use, sketches the algorithms used in generating implementations from these specifications, and describes a UNIX®-based automated implementation system for RTAG. [ABSTRACT FROM AUTHOR]

In today's distributed computing environment, the coordination of concurrent processes and the coordination of resource sharing are of critical importance. Consequently, much effort has been focused on the modeling of problems of coordination and concurrency. In this paper we describe a software environment (SPANNER) for the specification and analysis of such problems. In the SPANNER environment, one can formally produce a specification of a distributed computing problem, and then verify its "correctness" through reachability analysis and simulation. SPANNER is based on a finite state machine model called the selection/resolution model. We illustrate the capabilities of SPANNER by specifying and analyzing two classical coordination problems: 1) the dining philosophers; and 2) Dijkstra's concurrent programming problem. In addition to discussing these specific problems, our intention is also to focus on some of the more recently implemented capabilities of the SPANNER system such as process types and cluster variables. [ABSTRACT FROM AUTHOR]

The present crisis in software development forces us to reconsider the fundamental ways in which programming is done. One often quoted solution is to exploit more fully the idea of reusable software. It is the purpose of this paper to examine this concept in all of its forms and to assess the current state of the art. In addition to its usual meaning of reusable code, reusability includes reusable design, various forms of specification systems, so-called application generators. and systems for prototyping. We examine each approach from the perspective of the practicing engineer, and we evaluate the work in terms of how it may ultimately improve the development process for large-scale software systems. [ABSTRACT FROM AUTHOR]

Managing software engineering projects requires an ability to comprehend and balance the technological, economic, and social bases through which large software systems are developed. It requires people who can formulate strategies for developing systems in the presence of ill-defined requirements, new computing technologies, and recurring dilemmas with existing computing arrangements. This necessarily assumes skill in acquiring adequate computing resources, controlling projects, coordinating development schedules, and employing and directing competent staff. It also requires people who can organize the process for developing and evolving software products with locally available resources. Managing software engineering projects is as much a job of social interaction as it is one of technical direction. This paper examines the social arrangements that a soft- ware manager must deal with in developing and using new computing systems, evaluating the appropriateness of software engineering tools or techniques, directing the evolution of a system through its life cycle, organizing and staffing software engineering projects, and assessing the distributed costs and benefits of local software engineering practices. The purpose is to underscore the role of social analysis of software engineering practices as a cornerstone in understanding what it takes to productively manage software projects. [ABSTRACT FROM AUTHOR]

Testing has long been in need of mathematical underpinnings to explain its value as well as its limitations. This paper develops and applies a mathematical framework that 1) unifies previous work on the subject, 2) provides a mechanism for comparing the power of methods of testing programs based on the degree to which the methods approximate program verification, and 3) provides a reasonable and useful interpretation of the notion that successful tests increase one's confidence in the program's correctness. Applications of the framework include confirmation of a number of common assumptions about practical testing methods. Among the assumptions confirmed is the need for generating tests from specifications as well as programs. On the other hand, a careful formal analysis of the usual assumptions surrounding mutation analysis shows that the "competent programmer hypothesis" does not suffice to ensure the claimed high reliability of mutation testing. Hardware testing is shown to fit into the framework as well, and a brief consideration of it shows how the practical differences between it and software testing arise. [ABSTRACT FROM AUTHOR]

Computations of distributed systems are extremely difficult to specify and verify using traditional techniques because the systems are inherently concurrent, asynchronous, and nondeterministic. Furthermore, computing nodes in a distributed system may be highly independent of each other, and the entire system may lack an accurate global clock. In this paper, we develop an event-based model to specify formally the behavior (the external view) and the structure (the internal view) of distributed systems. Both control-related and data-related properties of distributed systems are specified using two fundamental relationships among events: the "precedes" relation, representing time order; and the "enables" relations, representing causality. No assumption about the existence of a global clock is made in the specifications. The specification technique has a rather wide range of applications. Examples from different classes of distributed systems, include communication systems, process control systems, and a distributed prime number generator, are used to demonstrate the power of the technique. The correctness of a design can be proved before implementation by checking the consistency between the behavior specification and the structure specification of a system. Both safety and liveness properties can be specified and verified. Furthermore, since the specification technique defines the orthogonal properties of a system separately, each of them can then be verified independently. Thus, the proof technique avoids the exponential state-explosion problem found in state-machine specification techniques. [ABSTRACT FROM AUTHOR]

A fundamental step in the software design process is the selection of a refinement (implementation) for a data abstraction. This step traditionally involves investigating the expected performance of a system under different refinements of an abstraction and then selecting a single alternative which minimizes some performance cost metric. In this paper we reformulate this design step to allow different refinements of the same data abstraction within a computation. This reformulation reflects the fact that the implementation appropriate for a data abstraction is dependent on the behavior exhibited by the objects of the abstraction. Since this behavior can vary among the objects of a computation, a single refinement is often inappropriate. Accordingly, three frameworks are presented for understanding and representing variations in the behavior of objects and, thus, the potential for multiple implementations. The three frameworks are based upon: 1) a static partitioning of objects into disjoint implementation classes; 2) static partitioning of classes into implementation regions; and 3) dynamic partitioning of classes into implementation regions. These frameworks and analytic tools useful in investigating expected performance under multiple implementations are described in detail. [ABSTRACT FROM AUTHOR]

This paper describes a multiview characterization of concurrent software and systems suitable for displaying and analyzing performance information. The views draw from well-known descriptions, and are compatible with established techniques and tools such as execution graphs, Petri Nets, State-Charts, structured design or object-oriented design, and various models for performance. The views are connected by means of a "Core model" and are used together to extract information relating to system integration, such as interprocess overheads, and the delay behavior of separate software components in complex systems. The integration of the views in the Core assists by converting results in one view (such as scheduling delay for resources) to parameters in another (such as delays along a path). The ultimate goal of the views is to support designers in making tradeoffs which involve performance, and to provide early assessment of the performance potential of software designs. [ABSTRACT FROM AUTHOR]

Software bottlenecks are performance constraints caused by slow execution of a software task. In typical client-server systems a client task must wait in a blocked state for the server task to respond to its requests, so a saturated server will slow down all its clients. A Rendezvous Network generalizes this relationship to multiple layers of servers with send-and-wait interactions (rendezvous), a two-phase model of task behavior, and to a unified model for hardware and software contention. Software bottlenecks have different symptoms, different behavior when the system is altered, and a different cure from the conventional bottlenecks seen in queueing network models of computer systems, caused by hardware limits. The differences are due to the "push-back" effect of the rendezvous, which spreads the saturation of a server to its clients. The paper describes software bottlenecks by examples, gives a definition, shows how they can be located and alleviated, and gives a method for estimating the performance benefit to be obtained. Ultimately, if all the software bottlenecks can be removed, the performance limit will be due to a conventional hardware bottleneck. [ABSTRACT FROM AUTHOR]

Distributed applications written in Hermes typically consist of a large number of sequential processes. The use of a hierarchy of process clusters can facilitate the debugging of such applications. Ideally, such a hierarchy should be derived automatically. This paper discusses two approaches to automatic process clustering, one analyzing runtime information with a statistical approach and one utilizing additional semantic information. Tools realizing these approaches were developed and a quantitative measure to evaluate process clusters is proposed. The results obtained under both approaches are compared, and indicate that the additional semantic information improves the cluster hierarchies derived. We demonstrate the value of automatic process clustering with an example. It is shown how appropriate process clusters reduce the complexity of the understanding process, facilitating program maintenance activities such as debugging. [ABSTRACT FROM AUTHOR]