bluuebunny/crossref_metadata_2025 huggingface dataset:
Measurements of a distributed file system
Authors: Baker Mary G. , Hartman John H. , Kupfer Michael D. , Shirriff Ken W. , Ousterhout John K.
Published: October 2004

We analyzed the user-level file access patterns and caching behavior of the Sprite distributed file system. The first part of our analysis repeated a study done in 1985 of the: BSD UNIX file system. We found that file throughput has increased by a factor of 20 to an average of 8 Kbytes per second per active user over 10-minute intervals, and that the use of process migration for load sharing increased burst rates by another factor of six. Also, many more very large (multi-megabyte) files are in use today than in 1985. The second part of our analysis measured the behavior of Sprite's main-memory file caches. Client-level caches average about 7 Mbytes in size (about one-quarter to one-third of main memory) and filter out about 50% of the traffic between clients and servers. 35% of the remaining server traffic is caused by paging, even on workstations with large memories. We found that client cache consistency is needed to prevent stale data errors, but that it is not invoked often enough to degrade overall system performance.
A method for mapping an analysis to a reusable design
Authors: Spicer Kelly L. , Umphress David A.
Published: October 2004

Design reuse has more potential for increasin g the productivity of software development and maintenance than does traditional approaches to software reuse. Current software developmen t methods do not promote design reuse. A design mapping method from an object-oriented requirements analysis to a design adhering to thes e principles is presented. The method involves tw o transformation steps and introduces four representation tools for conducting the transformations. The second step produces Ada specifications. Design templates are used. The method is applied to a sample problem.
Object-oriented graphics for requirements analysis and logical design
Authors: Firesmith Donald
Published: October 2004

Numerous graphic notations have been proposed during the last 5 years for use during Object-Oriented Requirements Analysis and Logical Design. The following article describes the consistent set of tool-supported object-oriented graphics that are part of ASTS Development Method 2 (ADM_2), a full development cycle method in use on various projects in the United States, Canada, and England.
Analysis of Ada-LINPACK benchmark results
Authors: Purser Lynn , Graham Robin
Published: October 2004

Implementation of standard algorithms coupled with immature optimization techniques often cause VAX/Ada's run-time performance to be less than optimal. An analysis of a VAX/Ada LINPACK benchmark test revealed that the storage scheme of two dimensional arrays and the column addressing of matrix elements leads to a disproportionate number of index computation multiplications. Further analysis shows how the LINPACK decomposition algorithm can be rewritten so that VAX/Ada run-time performance is optimized.
Simple yet complete heuristics for transforming data flow diagrams into Booch style diagrams
Authors: Solsi Swathi C. , Jones Edward L.
Published: October 2004

This paper presents some simple heuristics for transforming a requirements specification (for a non-real time application) expressed as a data flow diagram (DFD) into a design architecture expressed as an
extended
Booch diagram. This architecture provides a starting point for subsequent design refinement. The transformations based on simple heuristics were implemented in a research tool. We show that simple things work. We also show that the design architecture satisfies the property of completeness,
i.e.
all the information in the DFD is preserved in the Booch diagram, and that it has good coupling and cohesion properties. The design architecture is amenable to various design optimizations by automated or manual means.
A Reselect Alternative for Ada's Selective Wait Statement
Authors: Lee Pen-Nan , Chin Chi-Hua , Nehman William
Published: October 2004

The selective wait statement is the most important element of the Ada tasking model. When entry calls are guarded using global information such as the clock and the entry attribute COUNT, two basic problems can occur. These problems occur because these guards are evaluated once, at the beginning of execution of the selective wait statement, and are not retested. Either a call may be accepted even though its guard would currently evaluate to false, or a call cannot be accepted even though its guard would currently evaluate to true. This paper describes these problems, offers solutions available without any language changes and then proposes an additional feature called
reselect
which adds to the operation of the selective wait statement and is an optional addition to an existing language construct.
Concurrent reusable abstract data types
Authors: Carter Jeffrey R.
Published: October 2004

A commonly used form of concurrent abstract data types always leads to erroneous execution. A corrected version of this form, suggested in the article which pointed out this problem, is not considered to be acceptable software engineering practice by the author. An acceptable correct form is presented.
The muse object architecture
Authors: Yokote Yasuhiko , Teraoka Fumio , Mitsuzawa Atsushi , Fujinami Nobuhisa , Tokoro Mario
Published: October 2004

A next generation operating system should accommodate an ultra large-scale, open, self-advancing, and distributed environment. This environment is dynamic and versatile in nature. In it, an unlimited number of objects, ranging from fine to coarse-grained, are emerging, vanishing, evolving, and being replaced; computers of various processing capacities are dynamically connected and disconnected to networks; systems can optimize object execution by automatically detecting the user's and/or programmer's requirements. In this paper, we investigate several structuring concepts in existing operating systems. These structuring concepts include layered structuring, hierarchical structuring, policy/mechanism separation, collective kernel structuring, object-based structuring, open operating system structuring, virtual machine structuring, and proxy structuring.We adjudge that these structuring concepts are not sufficient to support the environment described above because they lack the abilities to handle dynamic system behavior and transparency and to control dependency. Thus, we propose a new operating system structuring concept which we call the Muse object architecture. In this architecture, an object is a single abstraction of a computing resource in the system. Each object has a group of meta-objects which provide an execution environment. These meta-objects constitute a meta-space which is represented within the meta-hierarchy. An object is causally connected with its meta-objects: the internal structure of an object is represented by meta-objects; an object can make a request of meta-computing; a meta-object can reflect the results of meta-computing to its object. We discuss object/meta-object separation, the meta-hierarchy, and reflective computing of the architecture. We then compare the Muse object architecture with the existing structuring concepts.We also demonstrate that the Muse object architecture is suitable for structuring future operating systems by presenting several system services of the Muse operating system such as class systems, a real-time scheduler with hierarchical policies, and free-grained objects management. Class systems facilitate programming by several classes of programming languages. A real-time scheduler with hierarchical policies can meet various types of real-time constraints presented by applications. Free-grained objects management can suit the object granularity to the application, so that an object is efficiently managed according to its granularity. Finally, we present the implementation of the Muse operating system which is designed based on the Muse object architecture. Version 0.3 of the Muse kernel is running on the MC68030 based Sony NEWS workstations.
Two years of experience with a μ-Kernel based OS
Authors: Liedtke Jochen , Bartling Ulrich , Beyer Uwe , Heinrichs Dietmar , Ruland Rudolf , Szalay Gyula
Published: October 2004

This paper describes the basic components of the L3 operating system and the experiences of the first two years using it. The system results from scientific research, but is addressed to commercial application. It is based on a small kernel handling tasks, threads and dataspaces. User level device drivers and file systems are described as examples of flexible OS services realized outside the kernel.
Fault tolerance using group communication
Authors: Kaashoek M. Frans , Tanenbaum Andrew S.
Published: October 2004

We propose group communication as an efficient mechanism to support fault tolerance. Our approach is based on an efficient reliable broadcast protocol that requires on average only two messages per broadcast. To illustrate our approach we will describe how the task bag model can be made fault-tolerant using group communication.
Fast causal multicast
Authors: Stephenson Pat , Birman Kenneth
Published: October 2004

We begin by outlining a new protocol that efficiently implements a reliable, causally ordered multicast primitive and is easily extended into a totally ordered one. Since measurements show that the dominant cost of this protocol is message transport, the design of a lower level
multicast transport
protocol is discussed. The overall scheme scales with bounded overhead. Our first conclusion is that systems such as Isis can achieve performance competitive with the best existing multicast facilities - a finding contradicting the widespread concern that fault-tolerance may be unacceptably costly. Our second conclusion is that the paradigm of multicast transport is extremely useful for constructing fault-tolerant applications. Our final conclusion is that the framework for fault-tolerant programming provided by Isis is very useful in the design and construction of these extensions to the basic system.
Atomic broadcast in one phase
Authors: Minet Pascale , Anceaume Emmanuelle
Published: October 2004

An atomic broadcast protocol should meet the three properties of unanimity, order and termination. The protocol presented here assumes weak fail-silent Network Attachment Controllers (NACs) and a broadcast channel subject to omission failures. In a failure-free environment it consists of a single phase. The response time achieved is almost the same as for a simple broadcast. In case of receivers failures, the number of phases depends on failure occurrences. In case of a broadcaster failure all the correct receivers detect the failure and all the receivers ignore the broadcast. This protocol ensures that each correct NACs has the same view of the correct NACs' list.
Availability in the Sprite distributed file system
Authors: Baker Mary , Ousterhout John
Published: October 2004

In the Sprite environment, tolerating faults means recovering from them quickly. Our position is that performance and availability are the desired features of the typical locally-distributed office/engineering environment, and that very fast server recovery is the most cost-effective way of providing such availability. Mechanisms used for reliability can be inappropriate in systems with the primary goal of performance, and some availability-oriented methods using replicated hardware or processes cost too much for these systems. In contrast, availability via fast recovery need not slow down a system, and our experience in Sprite shows that in some cases the same techniques that provide high performance also provide fast recovery. In our first attempt to reduce file server recovery times to less than 90 seconds, we take advantage of the distributed state already present in our file system, and a high-performance log-structured file system currently under implementation. As a long-term goal, we hope to reduce recovery to 10 seconds or less.
An ada object-based analysis and design approach
Authors: Walters Neal L.
Published: October 2004

Cost and quality are becoming increasingly important for companies developing software for the Federal Government. Since much of the software developed for the Government must he written in Ada, software engineers and managers are searching to improve the process of developing Ada systems.Based on the potential of object-oriented methods-better maintainability, reusability, and intellectual control for large complex systems-we have implemented and are continuing to evolve a real-time object-oriented approach for developing Ada systems. Our process borrows heavily from the work of others and offers unique techniques for expressing object behavior, verifying and validating the object-oriented models, and mapping the object-oriented requirements model to Ada constructs. The approach we present in this paper incorporates object-oriented methods for both requirements analysis and Ada design, and focuses on:•Ada considerations for the object-oriented models•Transitioning from the requirements analysis model to Ada design with a minimum of
corner-turning
•Real-time behavior specifications for object services•A common method for verifying the requirements analysis model and validating the design model.
Reducing edge connectivity to vertex connectivity
Authors: Galil Zvi , Italiano Giuseppe F.
Published: October 2004

We show how to reduce edge connectivity to vertex connectivity. Using this reduction, we obtain a linear-time algorithm for deciding whether an undirected graph is 3-edge-connected, and for computing the 3-edge-connected components of an undirected graph.
A study of preemptable vs. non-preemptable token reservation access protocols
Authors: Strayer W. Timothy
Published: October 2004

LAN protocols based on token reservation, like those found in the IEEE 802.5 Token Ring and the SAE High Speed Ring Bus LAN specifications, service messages in
nearly
priority order. Token Reservation fails when higher priority messages enter the system too late to be included in the priority bidding scheme or after a lower priority message successfully captures the token. Although allowing preemption in the media access protocol could reduce or eliminate these failings, no preemptable protocol exists among the extant LAN protocols. We are interested in whether preemption service in LANs could improve service for high priority messages; since no LAN with preemption currently exists, we developed a preemption protocol and tested it in simulation. We compare this protocol with non-preemption protocols using conventional metrics (such as throughput and delay), as well as introducing a new metric, the
priority inversion ratio,
to quantify the effectiveness of the protocols for providing priority-ordered service. We show that non-preemptable token reservation protocols suffer from priority inversion. We also show that a preemption protocol indeed provides better service to high priority messages at the expense of lower priority messages, and that this improvement is measurable.
Managing data derived from multiple sources in an X.500 Directory
Authors: Barker Paul
Published: October 2004

X.500 Directories will not often be used as the master source of data until the Directory is well established, and the technology trusted. Until then there will remain the substantial problem of keeping an X.500 Directory up-to-date, frequently from a number of sources. Usually the volume of data will require that maintenance procedures are as automated as possible.However, naive procedures will not suffice for a number of reasons: different sources will name the same object differently; different sources will name different objects the same; the data obtained from these sources may overlap to some extent, though one source may be regarded as more authoritative than another.It is recognised that a complete solution to these data merging and updating problems will be quite complex, and such a solution is not essayed here. Instead, this paper proposes some pragmatic solutions to the majority of the problems. It is anticipated that further understanding of the problems will result from experimentation with an implementation of the tools described herein.
Connections with multiple congested gateways in packet-switched networks part 1
Authors: Floyd Sally
Published: October 2004

In this paper we explore the bias in TCP/IP networks against connections with multiple congested gateways. We consider the interaction between the bias against connections with multiple congested gateways, the bias of the TCP window modification algorithm against connections with longer roundtrip times, and the bias of Drop Tail and Random Drop gateways against bursty traffic. Using simulations and a heuristic analysis, we show that in a network with the window modification algorithm in 4.3 tahoe BSD TCP and with Random Drop or Drop Tail gateways, a longer connection with multiple congested gateways can receive unacceptably low throughput. We show that in a network with no bias against connections with longer roundtrip times and with no bias against bursty traffic, a connection with multiple congested gateways can receive an acceptable level of throughput.We discuss the application of several current measures of fairness to networks with multiple congested gateways, and show that different measures of fairness have quite different implications. One view is that each connection should receive the same throughput in bytes/second, regardless of roundtrip times or numbers of congested gateways. Another view is that each connection should receive the same share of the network's scarce congested resources. In general, we believe that the fairness criteria for connections with multiple congested gateways requires further consideration.
Adaptive admission congestion control
Authors: Haas Zygmunt
Published: October 2004

In this paper, we describe a novel congestion control scheme for high-speed networks. The scheme is based on periodic transmission through the network of time-stamped sampling packets that sense the congestion status of the network. Upon reception, the sampling packet delays are calculated, averaged, and used to determine the state of the network. The information on the state of the network is then used to drive the network adaptive admission control. The major advantage of the proposed scheme over conventional congestion control techniques is that it copes with traffic surges that are shorter than the network round-trip delay. This is achieved by controlling traffic admission with continuous estimate of the network state. The scheme is targeted toward networks that carry aggregated traffic, and can be applied to ATM-based networks.
Semaphores for fair scheduling monitor conditions
Authors: Dunstan Neil
Published: October 2004

Although semaphores provide an adequate means to represent monitor condition variables, enhancements are necessary when fair scheduling is required. In this context, fair scheduling means that a process which waits on a condition is released before any subsequent processes which wait on the condition. Two solutions are shown which utilize enhanced forms of semaphores.
Introduction to the proposed standard for the elementary functions in Ada
Authors: Dritz Kenneth W.
Published: October 2004

Since the conclusion of its three-year development period in 1989, the proposed Standard fora Generic Package of Elementary Functions for Ada has been working its way through a hierarchy of committees towards achieving the status of a secondary ISO standard in the Ada area. This article introduces the contents of the proposed standard and discusses some of the decisions that influenced it.
A portable generic elementary function package in Ada and an accurate test suite
Authors: Tang Ping Tak Peter
Published: October 2004

A comprehensive set of elementary functions has been implemented portably in Ada. The high accuracy of the implementation has been confirmed by rigorous analysis. Moreover, we present new test methods that are efficient and offer a high resolution of 0.005 unit in the last place. These test methods have been implemented portably here and confirm the accuracy of our implemented functions. Reports on the accuracy of other function libraries obtained by our test programs are also presented.
An Ada math library for real-time avionics
Authors: Celarier Donald A. , Sando Donald W.
Published: October 2004

This paper describes an ideal Ada math library for use in embedded, real-time avionics, and a library implementation based on this model for a "standard" military avionics processor. The special requirements and implementation considerations for avionics applications are discussed, and the design and specification of an Ada math library closely matching these stringent requirements is put forward. Evaluation procedures are briefly discussed, including new techniques for accuracy testing without requiring higher precision.
Rationale for the Proposed Standard for a Generic Package of Primitive Functions for Ada
Authors: Dritz Kenneth W.
Published: October 2004

This paper supplements the "Proposed Standard for a Generic Package of Primitive Functions for Ada," written by the ISO-IEC/JTC1/SC22/WG9 (Ada) Numerics Rapporteur Group. Based on recommendations made jointly by the ACM SIGAda Numerics Working Group and the Ada-Europe Numerics Working Group, the proposed primitive functions standard is the second of several anticipated secondary standards to address the interrelated issues of portability, efficiency, and robustness of numerical software written in Ada. Its purpose, features, and developmental history are outlined in this commentary.
Site optimal termination protocols for a distributed database under network partitioning
Authors: Cheung David , Kameda Tiko
Published: October 2004

Partition failure causes a major problem for the availability of a distributed database system. No protocol can consistently terminate all parts of a distributed transaction under all possible partitions, since some sites executing subtransactions may not know that other sites have already committed (or aborted) and, therefore, must wait until the failure is repaired. Under a site optimal termination protocol, the expected number of waiting sites is minimized, hence it maximizes the "availability" of a database system in the presence of partition failures. We introduce a new class of partition failures. We introduce a new class of termination protocols, called size-based termination protocols, and identify site optimal termination protocols within this class.
On table fragmentation in virtual memory management
Authors: Rattan I , Singh L P S
Published: October 2004

Virtual memory management (VMM) schemes have been in use for several years. All the text books on Operating Systems, including the widely used ones [1, 2], present the ideas involved in some detail. However, none of these provides details of a rather important aspect, namely, table fragmentation. In [1] there is a passing reference (p. 229) "... The waste of storage due to excessively large tables is called table fragmentation", and in [2] there is no mention of it at all.
The alchemy model: a model for homogeneous and heterogeneous distributed computing system
Authors: Pratt S. J.
Published: October 2004

The performance of any computing system is seriously affected by the performance of the resident operating system. Distributed computing systems are no different. There have been many successful attempts at harnessing the full potential offered by distributed computing's inherent flexibility. However by far the majority of these implementations have been made on homogeneous configurations; the complexity implicit in connecting a number of heterogeneous sub-systems into a single, unified distributed computing system, has precluded their realisation. The system designer has to compare the many characteristics of a design before deciding upon the final solution. In doing so the designer needs a framework, or model, upon which he can assess alternative strategies. Most of the models to date have been based upon the layered approach which simplfies the software strucutre but it cannot reflect the control infrastructure which is necessary to effect such facilities as reconfigurability, resilience. etc.
Distributed match-making for processes in computer networks
Authors: Mullender Sape J , Vitanyi Paul M B
Published: October 2004

In the very large multiprocessor systems and, on a grander scale, computer networks now emerging, processes are not tied to fixed processors but run on processors taken from a pool of processors. Processors are released when a process dies, migrates or when the process crashes. In distributed operating systems using the service concept, processes can be clients asking for a service, servers giving a service or both. Establishing communication between a process asking for a service and a process giving that service, without centralized control in a distributed environment with mobile processes, constitutes the problem of distributed match-making. Logically, such a match-making phase precedes routing in store-and-forward computer networks of this type. Algorithms for distributed match-making are developed and their complexity is investigated in terms of message passes and in terms of storage needed. The theoretical limitations of distributed match-making are established, and the techniques are applied to several network topologies.
Interfacing user processes an kernel in high level language
Authors: Ancona M , Clematis A , Gianuzzi V
Published: October 2004

We present a method to simplify the implementation of a kernel supporting a high level concurrent language on a bare multiprocessor system.User and system level languages (with as much common syntax as possible) are defined. The system language consists of those constructs which do not require concurrency support, plus other facilities which make it well suited to write the kernel supporting the user language. Such constructs must provide the equivalent of a supervisor call interface within a high level language.All machine dependencies for both the system and user languages have been encapsulated in the code generation phase of the compilation process. Our method reduces the retargeting problem of a kernel to the orientability problem of the code generator.Finally our experiences in using such methodology are discussed.
An algorithm for replicated directories
Authors: Spector Alfred Z , Daniels Dean
Published: October 2004

This paper describes a replication algorithm for directory objects based upon Gifford's weighted voting for files. The algorithm associates a version number with each possible key on every replica and thereby resolves an ambiguity that arises when directory entries are not stored in every replica. The range of keys associated with a version number changes dynamically; but in all instances, a separate version number is associated with each entry stored on every replica. The algorithm exhibits favorable availability and concurrency properties. There is no performance penalty for associating a version number with every possible key except on Delete operations, and simulation results show this overhead is small.
Replicated procedure call
Authors: Cooper Eric C
Published: October 2004

A new mechanism for constructing highly available distributed programs is described. It combines remote procedure call with replication of program modules for fault tolerance.The set of replicas of a module is called a troupe. In a program constructed from troupes, what appears to the programmer as a single inter-module procedure call results in a replicated procedure call. A distributed program constructed in this way will continue to function as long as at least one member of each troupe survives.The semantics of replicated procedure calls and troupes are defined and algorithms are presented that support these semantics.
On the Peeper's Voronoi diagram
Authors: Aurenhammer F. , Stöckl G.
Published: October 2004

In the peeper's Voronoi diagram for
n
sites, any point in the plane belongs to the region of the closest site visible from it. Visibility is constrained to a segment on a line avoiding the convex hull of the sites. We show that the peeper's Voronoi diagram attains a size of Θ(
n
2
) in the worst case, and that it can be computed in
O
(
n
2
)time and space.
Getting advice from a computer: five models and a simulator
Authors: Licker Paul S.
Published: October 2004

This article introduces a simulation system---CARMART---that is useful in teaching and research in computer-based advising. Advising is seen as a contributor to the activity of concluding a set of actions. This article develops an extended model of concluding based on Simon's three stage model of decision making.A typology of advising situations is developed detailing five increasingly powerful advising situations: 1) contextualization 2) data query and report facilities (MIS); 3) consultant advice on past history (CS); 4) logical models; and 5) mathematical models (DSS). This scale is based on the degree of assist to the concluder and the amount of pre-existing knowledge necessary to construct and use valid models in providing the advice.CARMART provides a vehicle for teaching students about these four modes of advising, given a specific 19-factor description requiring a decision from the student concerning sales technique. In addition, CARMART is helping to test hypotheses about the applicability of each mode of advising to situations which differ in the ease of access to systematic knowledge. A relationship between the kind of advice required and the stage of concluding is posited and explored.
About logical clocks for distributed systems
Authors: Raynal Michel
Published: October 2004

Memory space and processor time are basic resources when executing a program. But beside this implementation aspect (this time resource is necessary but does not belong to the program semantics), the concept of time presents a more fundamental facet in distributed systems namely causality relation between events. Put forward by Lamport in 1978, the logical nature of time is of primary importance when designing or analyzing distributed systems. This paper reviews three ways (linear time, vector time and matrix time) which have been proposed to capture causality between events of a distributed computation and which consequently allow to define logical time.
Multiprocessor real-time threads
Authors: Schwan Karsten , Zhou Hongyi
Published: October 2004

Portability is an important attribute of real-time operating systems because their target hardware environments routinely vary from special purpose processors to parallel machines to distributed execution environments. In this paper, we address the issue of operating systems portability by development of a
real-time threads package
based on the Mach cthreads interface. Real-time threads have been implemented on standard Unix platforms and on a 32-node BBN Butterfly multiprocessor. In contrast to cthreads, the schedulability of real-time threads may be determined dynamically at the time of threads creation. In addition, any scheduling guarantees made at thread creation time are maintained when threads communicate or cooperate using the package's other primitives.
Synchronization of the producer/consumer problem using semaphores, monitors, and the Ada rendezvous
Authors: Hilzer Ralph C.
Published: October 2004

This paper addresses the following questions regarding single-processor synchronization of the producer/consumer problem using semaphores, monitors, and the Ada rendezvous:• How does each synchronization method handle encapsulation and information hiding?• What task granualarity (size of protected code) is possible for each method during mutual exclusion?• When a process gets the processor, can it execute unimpeded to the end of its time quantum while it has work to do, or are unnecessary process switches required?Encapsulation and information hiding can be used to produce reliable code, while task granularity and process switching are performance considerations. Since large and complex programs such as operating systems need to be reliable, encapsulation and information hiding is desirable. However performance is an important consideration too, so task granularity must be as small as possible, and unnecessary process switching should be avoided.
Computational geometry
Authors: O'Rourke Joseph
Published: October 2004

Recent solutions of three "art gallery" problems are reported. Three related still-open problems are discussed.
The p-shovelers problem
Authors: Luccio Fabrizio , Pagli Linda
Published: October 2004

In a winter morning one man shovels the snow from his driveway. When the job is finished he can get out with the car. In the neighbouring driveway p men remove the same amount of snow in one p-th of time. The next morning is snowy. As the single shoveler goes on, new snow falls making his job harder. The neighbouring shovelers work for a shorter time, and a smaller amount of snow falls meanwhile, so that they clean the driveway in less than one p-th of time. This seems to conflict with a folklore theorem on parallel speed-up.
Quality end user-developed applications
Authors: Amoroso Donald L. , Cheney Paul H.
Published: October 2004

This article examines the dimension of quality in end user-developed applications. Quality is defined as the degree to which an application of "high grade" accomplishes or attains its goal from the perspective of the user. We propose a definition for "quality" as a combination of end user information satisfaction and application utilization. We then discuss three measurement instruments that were developed to capture the dimensions of quality and assess their psychometric properties.
Neural networks
Authors: Tafti Mohammed H. A.
Published: October 2004

Despite significant advances in expert systems, efforts to build truly intelligent systems that approach reasoning and sensory ability of humans have not been rewarding. A new AI approach, neural networks, utilizes brain-like processing to emulate human learning. This approach will be the focus of commercial applications of AI in the 90s. This article will discuss major features of neural networks and address the impact of this approach on expert systems, as well as implications for research in this area.
Knowledge acquisition
Authors: Liou Yihwa I.
Published: October 2004

The application of expert systems has increased drastically in the last decade. The power of these systems derives from the knowledge they possess, rather than from the inference mechanism that they employ. To ensure the performance of an expert system, the acquisition of knowledge becomes a vital task in the development process. This article discusses issues related to people involved in the knowledge acquisition task, reviews techniques to acquire knowledge, and presents a methodology that offers a structured approach to knowledge acquisition. Trends in knowledge acquisition are discussed.
The spring model for knowledge-based systems analysis
Authors: Whitley Edgar A. , Poulymenakou Angeliki , Cornford Tony
Published: October 2004

This article presents the initial results of a case study undertaken to develop a knowledge-based system to support the management of information technology in small- and medium-sized businesses. It explores the prerequisites for undertaking investigations in such a context and presents a method for knowledge-based systems anlaysis that is flexible in allowing the consideration of the complex contextual factors in the domain, while providing guidance and control for the incremental development of understanding. The results of this analysis can support rigorous development and implementation activities
An organized, devoted, project-wide reuse effort
Authors: Bowen Gregory M.
Published: October 2004

Many projects have struggled with attempting reuse; however, both size and complexity of a large project create additional obstacles that can minimize the potential for software reuse. Therefore, successful software reuse can not be guaranteed solely by the use of Ada, object-oriented development methods, taxonomies, storage and retrieval systems, commercial libraries, software methods, standards, or configuration management systems! It was proposed [Bowen, 1990], that inorder for software reuse to succeed on large projects, these methods and techniques must be combined in a coordinated reuse effort. The software process must address issues related to the management of the development effort, in addition to addressing purely technical issues. This paper will present how th e concept of an
organized, devoted, project-wide
reuse effort has been practically applied by Computer Sciences Corporation (CSC), over the past year on the Advanced Automation System (AAS), as part of the team led by International Business Machines (IBM) Corporation.
In support of the Ada 9X real-time facilities
Authors: Burns A. , Wellings A. J.
Published: October 2004

The Ada9x mapping has been criticised as being over ambitious and at odds with the “minimum change maximum benefit” AJPO dictum. Consequently there is a need to cut back the scope of the proposed changes. This report considers the proposed changes which affect the programming of real-time single processor and multiprocessor systems.

We argue that protected records, select waiting, asynchronous transfer of control, nested asynchronous transfer of control are all
essential core facilities
, and if any of these are omitted the success of Ada 9x in addressing the needs of the real-time community would be in serious jeopardy. If language simplification are deemed necessary, we would advocate the removal of user-defined timers, finalisation (but not abort exit handlers), and protected record functions.
Implementation of classical mutual exclusion algorithms in Ada
Authors: Saeed Faisel , George K. M. , Samadzadeh M. H.
Published: October 2004

This paper presents a scheme for defining a simulation environment for n-process mutual exclusion algorithms based on an Ada virtual machine. Several algorithms have been implemented and tested in this simulation environment.
A simple TCP extension for high-speed paths
Authors: Wang Zheng , Crowcroft Jon , Wakeman Ian
Published: October 2004

RFC-1072 and RFC-1185 have proposed a new TCP option "Echo/Echo Reply", in which timestamps are carried in TCP headers to aid in extending the sequence number space beyond 32 bits. However, such an extension will add an extra 64 bits to the TCP header and will require option processing for each packet at both ends. In this paper, we propose a simpler TCP extension that expands the sequence number space without increasing the size of the TCP header.
IDRP protocol analysis
Authors: Rekhter Yakov
Published: October 2004

IDRP is an inter-domain routing protocol that is based on the
path-vector
routing algorithm. This paper analysis storage complexity of the protocol and suggests possible local techniques for reducing it.
SE-OSI
Authors: Newnan Owen
Published: October 2004

SE-OSI is a prototype of a support environment (SE) for Open Systems Interconnection (OSI). Written in the C++ programming language, it demonstrates object-oriented application programming interfaces (APIs) for OSI as well as Open Distributed Processing (ODP) and investigates transparent transition to OSI and ODP through use of common APIs. Preliminary benchmarks suggest that the SE-OSI approach is suitable for real-time applications. This approach is contrasted with communications APIs currently being developed in standards bodies and consortiums, with recommendations made as to future directions for standardization of APIs and supporting environments.
Message authentication with one-way hash functions
Authors: Tsudik Gene
Published: October 2004

Fast message integrity and authentication services are much desired in today's high-speed network protocols. Current message authentication techniques are mostly encryption-based which is undesirable for several reasons. In this brief paper, we introduce encryption-free message authentication based entirely on fast one-way hash functions. Two methods are presented and their strength is analyzed. The security of the proposed methods is based on the strength of the underlying one-way hash function.
Performance comparison of routing protocols under dynamic and static file transfer connections
Authors: Shakar A. Udaya , Alaettinoğlu Cengiz , Dussa-Zieger Klaudia , Matta Ibrahim
Published: October 2004

We compare the performance of two recently proposed distance-vector algorithms (Merlin-Segall and Extended Bellman-Ford) with a link-state algorithm (SPF), under varying file transfer workload. (Unlike the traditional distance-vector algorithms, these new distance-vector algorithms do not suffer from long-lived loops.) Our comparison is done using a recently developed network simulator. MaRS. We consider both dynamic and static file transfer connections, and both uniform and hotspot distributions of source-sink pairs. Our conclusion is that Extended Bellman-Ford performs as well as SPF in terms of delay and throughput. This suggests that distance-vector algorithms are appropriate for very large wide-area networks, since their space requirements are less than that of link-state algorithms.
Transmission facilities for computer communications
Authors: Fraser A. G. , Henry P. S.
Published: October 2004

This paper presents a brief introduction to architectures and technologies that probably will be used for wide-area communications. It starts with a review of the structure of today's network and some aspects of the
digital transmission
systems that dominate modem networks. Then the status and trends in wide-area transmission technology are addressed, first for the
backbone network
and then for the
local access network
. Local access refers to the transmission systems which connect customer premises to the nearestlocal exchange switch, and the backbone provides wide-area interconnection between local exchange switches.
Using inheritance and polymorphism with Ada in government sponsored contracts
Authors: Hirasuna Michael
Published: October 2004

A practical approach for coding object-oriented design in Ada is described. Even though Ada lacks direct support for two important object-oriented constructs, inheritance and polymorphism, an object-orient design can be implemente d with existing portable Ada constructs. More lines of code will be required t o defined the implied constructs of inheritance and polymorphism, but such cod e will have side benefits such as improved readability. The extra lines of code can be minimized with the use of coding rules.This paper does not suggest how Ada can be modified to implement inheritance and polymorphism; such matters are already being addressed by the Ada 9X committee. Instead, it is concern with meeting the needs of government sponsored contracts which require object-oriented design techniques and Ada as th e coding language. Furthermore, this must be done with Ada as it exists today [LRM] and should not require the use of precompilers.Without modification, Ada cannot be as flexible as an object-oriented language; but this is not the issue. In government contracted software, design and coding are distinct phases in the software development. The flexibility of the object-oriented approach can be used in the design phase independently from the target language. The issue is how to code a relatively stable object-oriented design in Ada.
Ada 9X reusable components
Authors: Carter Jeffrey R.
Published: October 2004

The inclusion of concurrency in Ada leads to multiple reusable components which implement th e same abstraction. The proposed modifications of Ada 9X contain features which may eliminate th e need for more than one version of an abstraction. An example of an Ada 9X component illustrates the use of these features.
Performance measures of the Ada Rendezvous
Authors: Sterrett Anthony , Minei Marvin
Published: October 2004

The Ada Programming Language [ADA], was designed to meet the nee d for a standard computer programming language. Ada has the ability to take advantage of multiprocessor environments. One feature, known as th e rendezvous, allows tasks to synchronize in such a environment. In this paper, we will look at the performance of the Ada rendezvous in a two-processo r system.In a distributed Ada system, the rendezvous provides synchronize d communication between asynchronous tasks. A system of this sort woul d consist of at least two processors, each serving various tasks. Presently, th e performance behavior of tasks which synchronize and possibly communicat e are not widely known. Developers of concurrent Ada systems will need t o perform sensitivity studies of the Ada tasking environment to develo p efficient time-critical programs. Therefore, we will discuss Rendezvou s Response Time from the point of view of a sensitivity study. We will sho w generalized performance curves of the rendezvous along with commentary o n their performance elbows (or bottlenecks). Rendezvous Response Time will b e defined as the amount of time one task must wait until its rendezvous request t o another task is completed. The discussion will be based on two separat e computer simulations of a two-processor system. The tools to be used to build these simulations are [ELSIR] and [APOSL].
Object-oriented programming in Classic-Ada
Authors: Nelson Michael L. , Mota Gilberto F.
Published: October 2004

Ada is not generally considered to be an object-oriented language. Classic-Ada is a preprocessor which adds the concepts of classes, inheritance, and dynamic binding to the Ada language. In this paper, we review the use of Classic-Ada as an object-oriented programming language.
How to program in Ada 9X, using Ada 83
Authors: Ploedereder Erhard
Published: October 2004

Existing software will have to be transitioned from Ada 83 to Ada 9X. This paper explains presently known incompatibilities between the existing Ada standard and its proposed revision. It provides guidelines to users, which will make their Ada 83 code upward compatible with Ada 9X.
Ada 9X protected types in Pascal-FC
Authors: Burns A. , Davies G. L.
Published: October 2004

In concurrent languages whose inter-process communication and synchronisation is based on message-passing, passive objects such as buffers are generally implemented as processes (tasks). This practice is not wholly satisfactory. The Ada9X mapping team have introduced the
protected type
as an abstraction for passive objects. This paper briefly describes the proposal and then reports on the introduction of a similar structure into Pascal-FC, a language designed for use in teaching concurrent programming. The paper therefore helps to inform the Ada community of this new feature in the language. Examples are given. Pascal-EC is freely available.
A critique of the Ada 9X mutual control mechanism (requeue) and an alternative mapping (onlywhen)
Authors: Verün Ufuk , Elrad Tzilla
Published: October 2004

Protected Record (PR) is the proposed Ada 9X light-weight synchronization mechanism. We assume that the reader is familiar with the Ada 9X proposal for PR [DoD, DPW, BW]. The requeue is one of the Ada 9X mappings of the requirement for flexibility and user control over scheduling. Requeue implements the requirement for Mutual Control which is the capability to make adecision based on a relationship among the states of both parties in a rendezvous (Relationship between parameters passed in by the caller task and the state of a protected record/called task).In the August 1991 Ada 9X Mapping Rationale there is a discussion about the requeue proposal aimed at the improvement of real-time features of Ada language [MR]. We propose an alternative mapping called onlywhen barrier for the realization of Mutual Control. Our mapping seems like requiring relatively more changes in the semantics definitions and resulting in increased run-time costs, but reducing the complexity of the code substantially and ultimately making the implementation of the Mutual Control more efficient than by using the requeue. A resource allocation problem and some solutions to it utilizing requeue and private entries are presented in [MR] and also summarized in [BW]. We examine the same problem and provide alternative solutions using the onlywhen proposal.