Search

In this paper, we investigated the applicability of ChatGPT AI in electronics research and development via a case study of applied sensors in embedded electronic systems, a topic that is rarely mentioned in the recent literature, thus providing new insight for professionals and academics. The initial electronics-development tasks of a smart home project were prompted to the ChatGPT system to find out its capabilities and limitations. We wanted to obtain detailed information on the central processing controller units and the actual sensors usable for the specific project, their specifications and recommendations on the hardware and software design flow additionally. Furthermore, an extensive literature survey was requested to see if the bot could offer scientific papers covering the given topic. It was found that the ChatGPT responded with proper recommendations on controllers. However, the suggested sensor units, the hardware and software design were only partially acceptable, with occasional errors in specifications and generated code. The results of the literature survey showed that non-acceptable, fabricated citations (fake authors list, title, journal details and DOI—Digital Object identifier) were presented by the bot. The paper provides a detailed qualitative analysis, a performance analysis and critical discussion of the aforementioned aspects while providing the query set, the generated answers and codes as supplied data with the goal to give added value to electronics researchers and developers if trying to reach out for the tools in their profession. [ABSTRACT FROM AUTHOR]

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.

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]

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]

In the context of technology development and systems engineering, knowledge is typically treated as a complex information structure. In this view, knowledge can be stored in highly sophisticated data systems and processed by explicitly intelligent, software-based technologies. This paper argues that the current emphasis upon knowledge as information (or even data) is based upon a form of rationalism which is inappropriate for any comprehensive treatment of knowledge in the context of human-centred systems thinking. A human-centred perspective requires us to treat knowledge in human terms. The paper sets out the particular importance of tacit knowledge in this regard. It sets out two case studies which reveal the critical importance of a careful treatment of tacit knowledge for success in two complex, technology-driven projects. [ABSTRACT FROM AUTHOR]

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]

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]

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]

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]

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 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]

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]

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]

Abstract: Modeling flows, be it from surface water or ground water, often require using (legacy) serial application codes that have been formulated, strengthened and tested by various audiences over a span of a few years. A limitation in using these serial codes for modeling large-scale transient flows lies in the order of required computational time for completing the simulation. Strategies aimed at addressing this limitation without extensive modifications to the code can further enhance their application without losing any of their current users. In this study, we take an existing popular three-dimensional finite-element hydrodynamic code (TABS-MDS), a product of the U.S. Army Corps of Engineers, and integrate it under the umbrella of an advanced software library: PETSc. The advantage of using the powerful solvers and preconditioners from the software library for solving the end system of equations is illustrated. The results indicate that the choice of the solver combination can have a significant effect on the end computational time. The target audience of this paper are the numerical modelers from a multitude of disciplines who are interested in enhancing the performance of their serial codes. [Copyright &y& Elsevier]

Dynamic structured adaptive mesh refinement (SAMR) techniques along with the emergence of the computational Grid offer the potential for realistic scientific and engineering simulations of complex physical phenomena. However, the inherent dynamic nature of SAMR applications coupled with the heterogeneity and dynamism of the underlying Grid environment present significant research challenges. This paper presents application/system sensitive reactive and proactive partitioning strategies that form a part of the GridARM autonomic runtime management framework. An evaluation using different SAMR kernels and system workloads is presented to demonstrate the improvement in overall application performance. [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]

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]

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]

This paper presents a chaotic oscillator based on the nonlinearity of the typical transconductance (Gm). This chaotic circuit only consists of 13 MOS transistors and three grounded capacitors, which is one of the smallest chaotic oscillators. This circuit operates on low voltage supply (±1.5 V). The dimensionless form of the circuit is also introduced to confirm the circuit simulation. [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]

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]

A model–based engineering diagnostic method is typically based on the evaluation of the residuals generated from a comparison of important variable values from a simulated system and the corresponding measured values from the system’s performance. Consequently, a model should describe the dynamic behaviour of the system as accurately as possible using suitably selected parameter values. This implies the need for validation of the performance of the model by comparison with the measurements of the actual system. This process is especially important when the detection of faults is performed in real–time conditions. In this paper, the modelling process for hydraulic systems as well as a new parameter validation method that has been developed using the DASYLab data acquisition and control software for the estimation of the uncertain parameter values of the model is presented. This model validation process led to the establishment of a model–based expert system that is able to diagnose real–time faults working in parallel with actual dynamic industrial automated processes. [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]

In order to effectively optimize complex programs built in a layered or recursive fashion (possibly from reused general components), the programmer has a critical need for performance information connected directly to the design decisions and other optimization opportunities present in the code. Call path refinement profiles are novel tools for guiding the optimization of such programs, that: 1) provide detailed performance information about arbitrarily nested (direct or indirect) function call sequences, and 2) focus the user's attention on performance bottlenecks by limiting and aggregating the information presented. This paper discusses the motivation for such profiles, describes in detail their implementation in the CPPROF profiler, and relates them to previous profilers, showing how most widely available profilers can be expressed simply and efficiently in terms of call path refinements. [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]

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]

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, 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]

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 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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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 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.

The article presents the content of the June 1978 issue of the journal "ACM Computing Surveys." This issue's four papers share the theme of computer system engineering. The first paper gives us a much needed glimpse into the Soviet system of computers; the second describes successful approaches to keeping computer systems operating despite incorrect software and unreliable hardware; the third reveals the unseen world of error recovery in data management systems; and the fourth evaluates the state of software engineering. Since the days of the debate over structured programming, there has been much progress in understanding the engineering of large software systems. Recent studies have shown that the design and coding stages, wherein structured programming is most visible, constitute about 35% of the effort to ready a software product for delivery. These studies have also shown that the maintenance required to keep a software product operational after delivery typically amounts to 2/3 of the total cost of the product.