In this panel, the experience adopting and adapting computer science education to the availability of generative AI will be examined from multiple international perspectives spanning varied educational and cultural contexts: the Arab world, India, Latin America, and the US. This will help computer science educators compare notes on what they teach, how they teach, and how students engage with the emerging tools. It will provide an opportunity to discuss how institutions are updating curricula, supporting faculty, and preparing students to use generative AI effectively and responsibly. The premise of the panel is that the similarities among these contexts outweigh the educational and cultural differences. Given how generative AI is dominating the discussion of computer science curricula, the global conversation will be of interest to all computer science educators.

The latest in the series of computer science curricular guidelines produced by the ACM in collaboration with IEEE-Computer Society and the AAAI is CS2023 (csed.acm.org). Given that generative AI had only been available for a short while at the time of publication of CS2023, the task force that drafted CS2023 could at best speculate on its impact on the curricular guidelines. Two years later, this special session explores how the design of some of the knowledge areas of CS2023 most affected by generative AI could/should change in terms of content, pedagogy, assessment and policies. Given the ubiquity of generative AI in computer science education and its rapid evolution, re-examination of its impacts on computer science curriculum on an ongoing basis is both warranted and needed.

Physiological signals hold immense potential for ubiquitous emotion monitoring, presenting numerous applications in emotion recognition. However, harnessing this potential is hindered by significant challenges, particularly in the collection of annotations that align with physiological changes since the process hinges heavily on human participants. In this work, we set out to study human participants' perspectives in the emotion data collection procedure. We conducted a lab-based emotion data collection study with 37 participants using 360° virtual reality video stimulus followed by semi-structured interviews with the study participants. Our findings presented that intrinsic factors like participants' perception, experiment design nuances, and experiment setup suitability impact their emotional response and annotation within lab settings. Drawing from our findings and prior research, we propose recommendations for incorporating participants' context into annotations and emphasizing participant-centric experiment designs. Furthermore, we explore current emotion data collection practices followed by AI practitioners and offer insights for future contributions leveraging physiological emotion data.

As COVID made both students and teachers familiar with online teaching, it seems appropriate to explore a hybrid approach to teaching, in which the lectures are delivered in class but are simultaneously streamed online. An introductory programming course for an incoming cohort is frequently taught by having multiple sections, each being taught by an instructor, as colleges often have modest-sized classrooms that cannot accommodate the entire incoming cohort. Hybrid teaching can reduce the need for multiple instructors to teach different sections by having one large class. It also provides uniformity in instruction, which is hard to achieve with multiple sections. This poster shares our experience teaching a large introductory programming course in hybrid mode. The experience indicates that while in-class and overall attendance decline over the semester, online attendance is relatively steady and that most students attended a good fraction of lectures online. The data from in-class active learning quizzes also suggests that learning in lectures is similar for online and in-class students. Student feedback indicates that while a large fraction of students prefer in-class lectures for learning, a significant portion feels that both in-class and online are similar, and a fraction of students prefer online. Students' performance was somewhat correlated with total attendance but not the fraction attended in class or online. Overall, hybrid teaching of the introductory programming course has the potential advantage of increasing attendance and performance.

Productivity of a software development organization can be enhanced by improving the software process, using better tools/technology, and enhancing the productivity of programmers. This work focuses on improving programmer productivity by studying the process used by a programmer for executing an assigned task, which we call the task process. We propose a general framework for studying the impact of task processes on programmer productivity and also the impact of transferring task processes of high-productivity programmers to average-productivity peers. We applied the framework to a few live projects in Robert Bosch Engineering and Business Solutions Limited, a CMMI Level 5 company. In each project, we identified two groups of programmers: high-productivity and average-productivity programmers. We requested each programmer to video capture their computer screen while executing his/her assigned tasks. We then analyzed these task videos to extract the task processes and then used them to identify the differences between the task processes used by the two groups. Some key differences were found between the task processes, which could account for the difference in productivities of the two groups. Similarities between the task processes were also analyzed quantitatively by modeling each task process as a Markov chain. We found that programmers from the same group used similar task processes, but the task processes of the two groups differed considerably. The task processes of high-productivity programmers were transferred to the average-productivity programmers by training them on the key steps missing in their process but commonly present in the work of their high-productivity peers. A substantial productivity gain was found in the average-productivity programmers as a result of this transfer. The study shows that task processes of programmers impact their productivity, and it is possible to improve the productivity of average-productivity programmers by transferring task processes from high-productivity programmers to them.

Software productivity is influenced by how efficiently programmers execute tasks assigned to them. For executing a task, programmers execute several steps. How the execution of these steps is organized by a programmer is referred to as task process. While overall software process has been well studied, the impact of task processes has not been studied much. In this work, we study the impact of task processes on the productivity of programmers. We first model a task process as a Markov chain with each state representing a step, and then study the difference in task processes of high and low productivity programmers using the Euclidean distance between Markov chains. We applied this method in a field study conducted at Robert Bosch Engineering & Business Solutions Limited, a CMMi Level 5 software company. We analyzed the task processes of eighteen programmers from three live model-based unit-testing projects, and modeled them as Markov chains. We compared the task processes used by a programmer for executing similar tasks, and then compared the task processes of programmers within the same group (high/low productivity) and across groups. The results of the study indicate: a) each programmer uses similar task processes for executing similar tasks, though the task processes of a high productivity programmer are more similar than the task processes of a low productivity programmer, b) task processes of high productivity programmers are similar to each other, and c) task processes of a low productivity programmer differ widely from high productivity programmers.

We present an approach to identify duplicate bug reports expressed in free-form text. Duplicate reports needs to be identified to avoid a situation where duplicate reports get assigned to multiple developers. Also, duplicate reports can contain complementary information which can be useful for bug fixing. Automatic identification of duplicate reports (from thousands of existing reports in a bug repository) can increase the productivity of a Triager by reducing the amount of time a Triager spends in searching for duplicate bug reports of any incoming report. The proposed method uses character N-gram-based model for the task of duplicate bug report detection. Previous approaches are word-based whereas this study investigates the usefulness of low-level features based on characters which have certain inherent advantages (such as natural-language independence, robustness towards noisy data and effective handling of domain specific term variations) over word-based features for the problem of duplicate bug report detection. The proposed solution is evaluated on a publicly-available dataset consisting of more than 200 thousand bug reports from the open-source Eclipse project. The dataset consists of ground-truth (pre-annotated dataset having bug reports tagged as duplicate by the Triager). Empirical results and evaluation metrics quantifying retrieval performance indicate that the approach is effective.

Web services composition environment is highly dynamic with new services being deployed, existing ones becoming unavailable or their QoS and other non-functional properties (cost, availability, etc.) changing dynamically. However, current approaches for web services composition and execution, such as WS-BPEL, can neither tailor the execution automatically as per the required QoS nor can they adapt to the highly dynamic environment. Though there have been some recent efforts in this direction they are piecemeal and insufficient. They either do not take user's non-functional requirements (NFRs) into consideration for adaptation, or there is no standard way of specifying these requirements for a BPEL process. In this paper, we propose an integrated approach for dynamically adapting web service compositions based on NFRs. We first give a specification for representing NFRs for each partner service of a BPEL process, and then describe a system that dynamically adapts the BPEL process based on these requirements by selecting suitable services at runtime. The selected services only need to be semantically equivalent and the system automatically takes care of the syntactical differences between their interfaces. We integrated our system in an existing BPEL engine using aspect oriented approach and demonstrate via experiments that it has very little performance overhead even at high loads.

Though software engineering courses are taught within different types of programs, one common program is the computer science program. Within this program, most often there is an introductory course in software engineering, which is often the only course in this area that a student will take in his/her program. Due to the wide scope of the subject and the constraint of one course only, this introductory course remains one of the hardest courses to teach, and leads to the possibility of a variety of possible goals for such a course. In this talk we view a course like a software program-having a pre-condition and a post-condition, and then discuss the various possible pre and post conditions of such a course, and some issues related to teaching the course.

Presents the welcome message from the conference proceedings.

Code inspection and unit testing are two popular fault- detecting techniques at unit level. Organizations where inspections are done generally supplement it with unit testing, as both are complementary. A natural question is the order in which the two techniques should be exercised as this may impact the overall effectiveness and efficiency of the verification process. In this paper, we present a controlled experiment comparing the two execution-orders, namely, code inspection followed by unit testing (CI-UT) and unit testing followed by code inspection (UT-CI), performed by a group of fresh software engineers in a company. The subjects inspected program-units by traversing a set of usage scenarios and applied unit testing by writing JUnit tests for the same. Our results showed that unit testing can be more effective, as well as more efficient, if applied after code inspection whereas the later is unaffected of the execution- order. Overall results suggest that sequence CI-UT performs better than UT-CI in time-constrained situations.

Test driven development (TDD) is an approach for developing programs incrementally by first writing tests and then writing enough code to satisfy them. Though there have been some experiments for evaluating TDD on smaller scope, its impact on a larger scope of program development activities needs to be investigated. In this work, we evaluate the impact of TDD on various program development activities like designing, coding, and testing, through a controlled experiment where we compare it with the conventional way of developing the code. In a single-factor block design, two groups of students developed two moderately sized programs following the two development-styles under study. Our results suggest that TDD helps in reducing overall development effort and improving developer's productivity whereas the code quality seems to be affected by the actual testing efforts applied during a development-style.

Most software reliability growth models work under the assumption that reliability of software grows due to the removal of bugs that cause failures. However, another phenomenon has often been observed—the failure rate of a software product following its release decreases with time even if no bugs are corrected. In this article we present a simple model to represent this phenomenon. We introduce the concept of initial transient failure rate of the product and assume that it decays with a factor α per unit time thereby increasing the product reliability with time. When the transient failure rate decays away, the product displays a steady state failure rate. We discuss how the parameters in this model—initial transient failure rate, decay factor, and steady state failure rate—can be determined from the failure and sales data of a product. We also describe how, using the model, we can determine the product stabilization time—a product quality metric that describes how long it takes a product to reach close to its stable failure rate. We provide many examples where this model has been applied to data from released products.

A secure software demands effective techniques for vulnerability detection during its development cycle. The practice of detecting security flaws before the deployment phase eliminates the risks that vulnerabilities may impose for the company. Static analysis and dynamic analysis techniques offer two complimentary approaches for checking vulnerabilities. Static analysis involves the scanning of source code or binary eliminating the need of executing it. This approach is fast and has no run time overhead. However, static analysis are quite imprecise and generate huge false positives and false negatives. On the other hand, dynamic analysis involves the running of the software. The problem of false positives and negatives is less in case of dynamic analysis because they analyze by running the test cases. But this approach requires large number of test cases to ensure a certain confidence level in detecting security bugs. This paper describes a methodology which integrates the two approaches in a complimentary manner. It adopts the strengths of the two and eliminates their weaknesses. We are currently dealing with buffer overflow vulnerability with pointer aliasing. However the idea can be extended to other vulnerabilities also for e.g memory related errors, race conditions(time of check to time to use vulnerability), dangling pointer vulnerability, integer errors etc

Performance engineering is an important activity for software architects and designers. Assessment and tuning of performance can help to make key changes in the system, especially if done early in its development. In this paper, we present a tool for the performance assessment and tuning for systems following the tiered architecture, which is a very commonly used architecture style. The Web-based tool allows a software designer to specify the system under design and ascertain the different performance attributes as well as the variation in performance with load. If the predicted performance is not satisfactory, the tool helps the designer with ascertaining the changes that need to be done for achieving the desired performance. Using an iterative analysis, it presents the designer with detailed steps in terms of improvements at the software and the hardware level that are necessary to improve the system performance to the desired level. We present an overview of the analysis and tuning approach, along with an example to illustrate the use of the tool

Detecting security bugs during the development cycle of a software is extremely difficult as effective testing approaches for such bugs do not exist. Applications are often deployed without being tested for security vulnerabilities even though the application domain demands highly secure software. Hence there is a need to develop systems which can monitor such applications for security violations and take immediate actions if any violation occurs. In this paper we describe an approach for monitoring the security health of a software system. Our methodology involves an agent based approach which communicates with the health monitoring system running as an independent process. We make this agent a part of the application (binary) and modify the binary at appropriate locations to transfer the control to the agent attached. The agent sends critical information regarding the execution to the monitoring system. The monitoring system analyzes the data and takes suitable actions. Currently our system monitors the following security bugsuffer overflow, race conditions (time of check to time to use vulnerability), random number vulnerability and can be extended for other vulnerabilities also

In software products, often the failure rate decreases after installation, eventually reaching a steady state. The time it takes for a product to reach its steady state reliability depends on different product parameters. In this paper we propose a new metric for software products called stabilization time which is the time taken after installation for the reliability of the product to stabilize. This metric can be used for comparing products, and can be useful for organizations and individuals using the product as well as for the product vendor. We also present an approach for determining the stabilization time of a product from its failure and sales data. We apply the approach to three real life products using their failure and sales data after release

With the advent of globalization and the Internet, the concept of global software development is gaining ground. The global development model opens up the possibility of 24-hour software development by effectively utilizing the time zone differences. To harness the potential of the 24-hour software development model for reducing the overall development time, a key issue is the allocation of project tasks to the resources in the distributed team. In this paper, we examine this issue of task allocation in order to minimize the completion time of a project. We discuss a model for distributed team across time-zones and propose a task allocation algorithm for the same. We apply the approach on tasks of a few synthetic projects and two real projects and show that there is a potential to reduce the project duration as well as improve the resource utilization through 24-hour development.

We propose a caching scheme for saving the results of invocations of read methods at server side. Server side caching helps in reducing load on frequently accessed servers when computing the result is relatively costly. Our model provides strong consistency by using a dependency graph that specifies dependence information among method invocations of an object. We have implemented this scheme as a service in CORBA.

Most of the software reliability growth models work under the assumption that reliability of software grows due to the bugs that cause failures being removed from the software. While correcting bugs will improve reliability, another phenomenon has often been observed - the failure rate of a software product, as observed by the user, improves with time irrespective of whether bugs are corrected or not. Consequently, the reliability of a product, as observed by users, varies, depending on the length of time they have been using the product. One reason for this reliability growth is that as the users gain experience with the product, they learn to use the product correctly and find work-around for failure-causing situations. Another factor that affects this growth is that following the product installation, the user discovers that other actions may be required, like installing new drivers, upgrading other software to a compatible version, etc. to properly configure the new product. In this paper we present a simple model to represent this phenomenon - we assume that the failure rate for a product decays with a factor /spl alpha/ per unit time. Applying this failure rate decay model to the data collected on reported failures and number of units of the product sold, it is possible to determine the initial failure rate, the decay factor, and the steady state failure rate of a product. The paper provides a number of examples where this model has been applied to data captured from released products.

Abstract The grammar of the language in which some given code is written is essential for developing automated tools for maintenance, reengineering, and program analysis. Frequently grammar is available for a language but not for its variants that are implemented by various vendors and in which the given code may be written. In this work we address the problem of obtaining the grammar from source code, which can then be used for generating tools for the programs. We propose an incremental method for obtaining grammar for a particular language variant, from a set of programs written in the language variant and an approximate grammar (presumably of the standard language) with some user interaction. We also present the design of a tool for implementing this approach and our experience in working with grammars of C, C++ and COBOL. Copyright © 2004 John Wiley & Sons, Ltd.

Abstract To improve response time of a Web site, one replicates the site on multiple servers. The effectiveness of a replicated server system will depend on how the incoming requests are distributed among replicas. A large number of load‐balancing strategies for Web server systems have been proposed. In this paper we describe a testbed that can be used to evaluate the performance of different load‐balancing strategies. The testbed uses a general architecture which allows different load‐balancing approaches to be supported easily. It emulates a typical World Wide Web scenario and allows variable load generation and performance measurement. We have performed some preliminary experiments to measure the performance of a few policies for load balancing using this testbed. Copyright © 2003 John Wiley & Sons, Ltd.

Software development project employs some quality control (QC) process to detect and remove defects. The final quality of the delivered software depends on the effort spent on all the QC stages. Given a quality goal, different combinations of efforts for the different QC stages may lead to the same goal. In this paper, we address the problem of allocating resources to the different QC stages, such that the optimal quality is obtained. We propose a model for the cost of QC process and then view the resource allocation among different QC stages as an optimization problem. We solve this optimization problem using non-linear optimization technique of sequential quadratic programming. We also give examples to show how a sub-optimal resource allocation may either increase the resource requirement significantly or lower the quality of the final software.

Software process improvement (SPI) has emerged as a critical area for organizations involved in software development. There is now considerable evidence that SPI can provide substantial gains in quality, productivity, and cycle time. Currently, most organizations embarking upon a SPI program tend to use a framework like the Capability Maturity Model. We discuss lessons learnt in using these frameworks for software process improvement. First, three critical success factors are discussed. The remaining lessons have been grouped into three categories - framework related, process related, and SPI management related. For each category we discuss key lessons. These lessons are based on the experience of the author in implementing a CMU-based SPI program in a large software organization in India, and helping many organizations in India and other countries (primarily the US and Mexico) with their SPI programs.

There is increasing interest in using control charts for monitoring and improving software processes, particularly quality control processes like reviews and testing. In a control chart, control limits are established for attributes and, if any point falls outside the limits, it is assumed to be due to special causes that need to be identified and eliminated. If the control limits are too tight, they may raise too many "false alarms" and, if they are too wide, they may miss special situations. Optimal control limits will try to minimize the cost of these errors. In this paper, we develop a cost model for employing control charts for software processes using optimum control limits which can be determined. Our applications of the model suggest that, for quality control processes like inspection, optimum control limits may be tighter than those commonly used in manufacturing. We have also implemented this model as a Web service that can be used for determining optimum control limits.

Article Free Access Share on Moving from ISO9000 to higher levels of the CMM (tutorial session) Author: Pankaj Jalote View Profile Authors Info & Claims ICSE '00: Proceedings of the 22nd international conference on Software engineeringJune 2000 https://doi.org/10.1145/337180.337840Published:01 June 2000Publication History 0citation869DownloadsMetricsTotal Citations0Total Downloads869Last 12 Months8Last 6 weeks0 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Ordered broadcast is a communication paradigm which requires that all the nodes in the network receive a message, and that the nodes receive the different messages in the same order. Ordered broadcast is particularly useful for supporting fault tolerance in distributed systems. We present a protocol for ordered broadcasts in a CSMA/CD network that uses the high reliability and collision detection properties of these networks in a novel manner. The control of the protocol is distributed, and even if the sender of a message fails after transmitting a message which is missed by some nodes, the ordered broadcast property is satisfied. The protocol has a small overhead, but requires both hardware and software support for implementation.

Despite considerable evidence to show that inspections can help reduce costs and improve quality, inspections are not widely deployed in the software industry. One of the likely reasons for this is the "not applicable here (NAH)" syndrome-developers and managers believe that in their environment, inspections will not provide the benefits seen by other organizations. One of the big challenges for deploying inspections is to overcome this syndrome. We describe two experiments that can be conducted, with little effort, in an organization to obtain data from the organization to build a case for inspections. By conducting one of these experiments, we were able to effectively overcome the NAH syndrome in our organization-many developers and managers are now ready to try inspections in their projects. Though the purpose of the experiment was to overcome the syndrome, the data from the experiment also shows how code inspections compare with unit testing in terms of defect detection capability, and the effect of inspections on the overall cost of development.

Maintenance is the set of activities performed after the installation of software. It is well-known that, over the life-time of the software, the maintenance costs can far exceed the development costs. In this paper, we describe an experimental study on the effect of object orientation on maintenance. In particular, we focus on how object orientation fares in maintainability when compared to software designed using function-oriented approaches. For the experiment, a testbed was prepared which consisted of three problems, for each of which the requirement specification, a C implementation and a C++ implementation of an object-oriented design were available. Various maintenance exercises were performed on the the two versions of the projects and different metrics were collected. In these experiments, object-oriented software generally fared better for maintainability

The usual way of installing a new version of a software system is to shut down the running program and then install the new version. This necessitates a sometimes unacceptable delay during which service is denied to the users of the software. An online software replacement system replaces parts of the software while it is in execution, thus eliminating the shutdown. While a number of implementations of online version change systems have been described in the literature, little investigation has been done on its theoretical aspects. We describe a formal framework for studying online software version change. We give a general definition of validity of an online change, show that it is in general undecidable and then develop sufficient conditions for ensuring validity for a procedural language.

Voting is a general approach to maintain consistency of replicated data under node failures and network partitions. In voting, each node as assigned a particular number of votes, and any group with majority of votes can perform operations. Votes assigned to the nodes have a significant impact on the performance of a voting system. In this report, we propose an integer programming approach for determining the vote assignment for maximizing the throughput. We use Monte-Carlo simulation to find the most likely groups formed due to partition failures and use these groups to formulate vote assignment as an integer programming problem. We have developed a tool called vote assignment tool (VAT) that implements this approach. VAT takes as input the configuration of the network, and after formulating the problem as integer programming exercise, solves it to output a vote assignment. We have tried this approach for different networks and have found that in many cases this approach assigns votes equivalent to or better than the best vote assignment given by the various heuristics.

Data is often replicated in distributed systems to improve availability and performance. This replication is expensive in terms of disk storage since the existing schemes generally require full files to be stored at each site. In this paper, we present schemes which significantly reduce the storage requirements in replication based systems. These schemes use the coding method suggested by Rabin to store replicated data. The first scheme that we present is a modification of the simple voting algorithm and its quorum requirements. We then show how some of the extensions of the voting algorithm can also be modified to get storage efficient schemes for managing such replication. We evaluate the availability offered by these schemes and show that the storage space required to achieve certain availability are significantly lower than the conventional schemes with full file replication. Since coding is used, these schemes also provide a high degree of data security.>

Abstract The usual way of installing a new version of a piece of software is to shut down the running program and then install the new version. This necessitates a sometimes unacceptable delay during which service is denied to the users of the software. An on‐line software replacement system replaces parts of the software while it is in execution, thus eliminating the shutdown. In this paper, we describe a system for on‐line software version change for software written in the C language. When the change is initiated by the user, the system instantiates a new process with the new version of the software, transfers state from the old process to the new one at an appropriate time, and transfers the control to the new process. The user sees a minimal delay in this switchover.

A method is presented to detect index corruption and pointer corruption in B/sup +/-trees. The method uses the semantic information of indices and requires no extra pointers to be added to the data structure. Previous research on the robustness on B-trees has considered index corruption and pointer corruption separately and required extra pointers to be added to the data structure to achieve detectability, and correctability. The proposed method can detect and identify a single semantic or structural error.>

Data replication is often used to increase the availability of data in a database system. Voting schemes can be used to manage this replicated data. The authors use a simple model to study the capacity of systems using voting schemes for data management. Capacity of a system is defined as the number of operations the system can perform successfully, on an average, per unit time. The capacity of a system using voting is examined and compared with the capacity of a system using a single node. It is shown that the maximum increase in capacity by the use of majority voting is bounded by 1/p, where p is the steady-state probability of a node being alive. It is also shown that for a system employing majority voting, if the reliability of nodes is high, increasing the number of nodes to more than three gives only a marginal increase in capacity. Similar analyses are performed for three other voting schemes.>

A voting protocol that can reduce the communication costs in distributed systems significantly is proposed. The technique arranges nodes in small intersecting groups, such that a site, in absence of failures, needs to communicate only with members of its group to collect the quorum. A method for constructing such logical groups is presented. It is shown that the message overhead of any operation in a system of N nodes is O( square root N) when there are no or few failures in the system. The availability and the communication overheads of the proposed protocol are compared with those of existing protocols.>

A scheme for maintaining replicated files is suggested. The authors describe how the coding scheme suggested by M.O. Rabin (1987, 1989) can be used to store replicated data and how the voting algorithm and the quorum requirements change to manage this replication. It is shown that the disk storage space required to achieve a given availability is significantly lower than that for the conventional scheme with full file replication. Since coding is used, this scheme also provides a high degree of data security.>

The effect of the primary site approach for fault tolerance on the response time is studied. In the primary site approach, the service to be made fault tolerant is replicated at many nodes, one of which is designated as primary and the others as backups. All the requests for operations on the data object are sent to the primary site. The primary fails, one of the backups takes over as primary. The primary site periodically checkpoints its state on the backups. An analytical model for studying the average response time of the primary site system and analyzing the effects of the checkpointing frequency and the degree of replication on the response time is presented. This model is used to compare the response time of the system to that of a system without any fault tolerance.>

An environment that supports execution of programs using both N-version programming and recovery blocks in a uniform manner is described. For N-version programming, the system offers an easy and flexible way of specifying the target machines for the separate versions. The basic unit of fault tolerance supported by this system is at the procedure or function level. Each such program unit can be packaged as its own task, and different fault tolerance techniques can subsequently be employed, even within the same application. The environment also allows versions to be written in different programming languages and executed on different machines. This enhances the independence between the different versions, making the fault tolerance techniques more effective. This environment has been developed for use on Unix-based hosts and currently runs on a network of Sun and DEC workstations.>

An environment for prototyping distributed applications is described that supports different communication primitives with specified delays, and provides primitives to aid debugging and evaluation. The environment also supports heterogeneous computation in which processes can execute on different hardware. Different source languages can be used for coding different modules of the processes. The system has a centralized control and monitoring facility which is based on the Suntools window system. This approach allows users to develop distributed applications using existing languages and packages, as opposed to restricting users to using only specialized specification languages, and extends the type of work done by R. Hayes et al. (1988) by providing primitives to assist in profiling and instrumenting the applications.>

Two different schemes are presented to make commit protocols fault-tolerant. The first scheme ensures that a failed site can directly recover to a state which is consistent with all other sites, using only its local information. This scheme can only make commit protocols resilient to a single site failure. The second scheme ensures that failed sites can recover to a state consistent with all others with as few information exchanges as possible. This scheme can make commit protocols resilient to any type of site failure.>

The primary site approach is often used to support fault tolerance against node failures. The authors present an analytic model to evaluate the availability of a system using the primary site approach. The effect of the number of replicas and the checkpoint interval were studied using the model. The authors found that the optimal checkpoint interval is proportional to the square root of the checkpoint overhead and inversely proportional to the request arrival rate. For the degree of replication, the results depend on what kind of checkpointing scheme is used. In systems using the broadcasting scheme, it was found that there is no optimal degree of replication: increasing the degree of replication increases the availability. However, in systems using the point-to-point checkpointing scheme, an optimal degree of replication exists: increasing the degree of replication beyond this optimum decreases the availability. Although the authors only consider a single repair server in the system, the model can easily be extended to allow multiple repair servers.>

Abstract This paper describes the implementation of a test bed called SAHAYOG, for evaluating dynamic load‐sharing policies in which job‐transfer decisions are based on the state of the system. The test bed is implemented on a network of AT&T 3B2 minicomputers. It provides an interactive user interface for conducting load‐sharing experiments. Based on user‐specified parameters it creates independent job streams at different nodes in the network. Jobs are transferred among the nodes by the load‐sharing algorithm being evaluated. Each node collects data about the jobs, which are used to generate statistics about the experiment. Five load‐sharing algorithms are implemented and evaluated using the test bed under different load conditions and for various parameter values. These experiments confirm some earlier results about load sharing and also provide some new insights. SAHAYOG also contains an optional fault‐tolerance feature to handle single‐node failures, and evaluates the effect of fault tolerance on the performance of different policies.

An object is said to be resilient if operations on the object can be performed even if some nodes of the network fail. To support resiliency, copies of the objects are stored on different nodes, and access to different copies is coordinated. The properties of broadcast networks are utilized to devise a distributed scheme for implementing resilient objects. All the copies of an object are equivalent. If an operation is requested on an object, the operation is performed on all the copies of the object. No special mechanisms are needed if some copies are not available due to node failures, as long as there is at least one active node that has a copy of the object and the network does not get partitioned. Simulation results indicate that the number of messages needed to perform an operation increases slowly and the response time for performing an operation decreases as the number of copies increases.>

An extended object-oriented design methodology is proposed which incorporates a top-down, stepwise refinement approach in a coherent fashion. The extended object-oriented design methodology also includes a phase of progressive object refinement to support the nesting of objects, which would allow entities in real life that are composed of subentities to be modeled. A design example is included, and experiences encountered using this methodology in a course are described.>

A system is described that tests for the completeness of axiomatic specifications of abstract data types. For testing, the system generates a set of test cases and an implementation of the data type from the specifications. The generated implementation is such that if the specifications are not complete, the implementation is not complete, and the behavior of all of the sequences of valid operations on the data type is not defined. This implementation is tested with the generated test cases to detect the incompleteness of specifications. The system is implemented on a VAX system running Unix.>

The authors present a simple strategy for generating testcases for implementations of abstract data types, based on syntactic information about the operations on the type. The developed tool has been used on a number of different types including stacks, strings, etc. It is found that choosing depth 2 for generating the testcases results in an effective set of testcases for detecting errors and can provide 100% statement coverage if proper initial values are selected. There are no rules for selecting the initial values.>

A scheme is presented that makes a remote procedure call (RPC) mechanism fault-tolerant to hardware failures. Fault tolerance is provided by replicating the procedure at a group of nodes, called a cluster. The copies in a cluster are linearly ordered. A call to a procedure is sent to the first copy in the cluster and is propagated internally to all other copies. In the event of failures, the first copy in the cluster that has not failed returns the result to the caller. The scheme is transparent to the user and supports nested procedure calls. It has been implemented on a network of Sun workstations making use of Sun's existing RPC mechanism.>

Abstract This paper describes a system for automatically generating an implementation of an abstract data type from its axiomatic specifications. Such a system can be useful for rapid prototyping and for detecting inconsistencies in the specifications by testing the generated implementation. In the generated Implementation, an instance of the data type is represented by its state. An operation on the data type is implemented by a collection of functions — a function for each of the axioms specified for the operation, and a function for the operation that determines, depending on the state of the instance(s) on which the operation is being performed, which of the axioms of the operation is applicable. The system is developed on a Sun‐3 workstation running Unix. It is written in C and generates the implementation of the abstract data type in C.

Two complementary techniques have evolved for providing fault-tolerance in software: forward error recovery and backward error recovery. Few implementations permit both approaches to be combined within a particular application. Fewer techniques are available for the construction of fault-tolerant software for systems involving concurrent processes and multiple processors. Many schemes for supporting forward or backward recovery are based on some concept of an atomic action. The authors propose a mechanism for supporting an atomic action in a system of communicating sequential processes (CSP). The atomic action is used as the basic unit for providing fault-tolerance. The atomic action is called an FT-action, and both forward and backward error recovery are performed in the context of an FT-action.

We present a new protocol, called the Delay /Re-Read Protocol, for controlling concurrent access to a database. The protocol uses a combination of preventive and corrective measures for maintaining consistency. On recognizing that a transaction has read inconsistent data, the Protocol applies a corrective measure which requires the transaction to re-read some data. Alternatively, on recognizing that a transaction is about to write data which will result in inconsistency, the Protocol applies a preventive measure which delays the Write. A Read request is always granted without delay. The Protocol is deadlock-free, requires no backup data, and supports a greater degree of concurrency than Two Phase Locking. A transaction is never aborted or delayed indefinitely by the Protocol.