bluuebunny/crossref_metadata_2025 huggingface dataset:
A field-based collaboration strategy in MADCE
Authors: HE Yanxiang , DU Zhuomin , LI Xuhui , Cooley Donald H. , He Jing
Published: October 2004

In this paper, we propose a field-based collaboration algorithm that can be applied to searching the local-best co-agent within field. The dynamic "field" structure of the collaborating objects limits the range of information communicating and sharing, and adjusts the load of Agents dynamically. An efficient method for Agent's collaboration in MADCE is presented, which can balance the system load, reduce the executive cost, and broaden the ability of Distributed Computing Environment.
Evaluation of two security schemes for mobile agents
Authors: Sobrado Igor
Published: October 2004

In this article, we submit and compare two different but complementary approaches to the problem of protecting mobile agents in untrusted computing environments. The first alternative, a technique for protection of mobile agents built upon an asymmetric cryptographic system resistant to conventional cryptoanalysis techniques, is based on the application of
one-time keys
. The second solution, geared towards computing environments supporting
public-key cryptographic systems
, permits the simultaneous protection of the code and data areas of mobile agents that travel in an information network. This latter protection mechanism can be implemented using any asymmetric cryptosystem.We believe the protection strategies we have developed in our investigation are the first complete solution for the protection of mobile agents in distributed computing environments.
Improved AntNet routing
Authors: Barán Benjamín
Published: October 2004

AntNet is a new algorithm for packet routing in communication networks. In AntNet, a group of mobile agents (artificial ants) build paths between pair of nodes, exploring the network concurrently and exchanging data to update routing tables.This work, based in a previous work of the author [3], analyzes AntNet algorithms and proposes improvements, comparing their performance with respect to the original AntNet and other commercial algorithms. Simulation results indicate a better throughput of the improved proposals. So, AntNet and its variant here proposed are promising options for routing in large public networks such as Intemet.
Estimating the service time of web clients using server logs
Authors: Ardaiz Oscar , Freitag Felix , Navarro Leandro
Published: October 2004

This article proposes and evaluates measures for estimating the service time of a web client using server logs, only from the server side without introducing traffic into the network. The HTTP protocol is described as well as the different interactions between the web server, the communication components, and the web client application. The first measure is based on the time it takes for the web server application to deliver an object to its operating system, keeping in mind the buffer effect of the server network. The second measure also considers the inter-arrival times to the server application of the GET requests for the objects that are part of a web page. We propose formulas, validated experimentally, that relate the proposed measurements in the server with the different components that take part in a web transaction and the service time experienced by clients. We have carried out several experiments to evaluate the validity of the proposed measurements and the best measure estimates the service time of the client with an error below 20% for 90% of the requests. We observed a cyclic component in the measurements of the server that can simplify the estimation of future values. For this reason, the proposed measures may be used to know what is the service time the client perceives in each visit to a server. It can also be used by content distribution networks to choose between several replica located in different places in the Internet.
A framework for scalable global IP-anycast (GIA)
Authors: Katabi Dina , Wroclawski John
Published: October 2004

This paper proposes GIA, a scalable architecture for global IP-anycast. Existing designs for providing IP-anycast must either globally distribute routes to individual anycast groups, or confine each anycast group to a pre-configured topological region. The first approach does not scale because of excessive growth in the routing tables, whereas the second one severely limits the utility of the service. Our design scales by dividing inter-domain anycast routing into two components. The first component builds inexpensive default anycast routes that consume no bandwidth or storage space. The second component, controlled by the edge domains, generates enhanced anycast routes that are customized according to the beneficiary domain's interests. We evaluate the performance of our design using simulation, and prove its practicality by implementing it in the Multi-threaded Routing Toolkit.
Lower than best effort
Authors: Carlberg Ken , Gevros Panos , Crowcroft Jon
Published: October 2004

In recent years, the Internet architecture has been augmented so that Better-than-Best-Effort (BBE) services, in the form of reserved resources for specific flows, can be provided by the network. To date, this has been realized through two different and sequentially developed efforts. The first is known as Integrated Services and focuses on specific bounds on bandwidth and/or delay for specific flows. The Differentiated Service model was later introduced, which presented a more aggregated and local perspective regarding the forwarding of traffic. A direction that is missing in today's work on service models is a defined schema used to purposely degrade certain traffic to various levels below that of Best Effort. In a sense, a new direction that provides a balancing effect in the deployment of BBE service. This is particularly evident with continual and parallel short transaction flows (like that used for web applications) over low bandwidth links that are not subject to any backoff penalty incurred by congestion because state does not persist. In a more indirect perspective, our model correlates degraded service with the application of usage and security policies -- administrative decisions that can operate in tandem or disjointly from conditions of the network. This paper attempts to address these and other issues and presents the design and implementation of such a new degraded service model and queuing mechanism used to support it.
Asynchronous interactions on shared data
Authors: Collier William W.
Published: October 2004

In order to write algorithms which interact successfully on shared data, it is necessary to understand the assumptions which are made about each operation and to know whether or not the assumptions are met by the underlying hardware. There are several basic types of operations on shared data; from the number of these operations a measure of the degree of interaction between algorithms can be obtained. This measure can then be used to ensure that all instances of interaction are tested.
The design of the Venus Operating System
Authors: Liskov Barbara H.
Published: October 2004

The Venus Operating System is an experimental multiprogramming system which supports five or six concurrent users on a small computer. The system was produced to test the effect of machine architecture on complexity of software. The system is defined by a combination of micro-programs and software. The microprogram defines a machine with some unusual architectural features; the software exploits these features to define the operating system as simply as possible. In this paper the development of the system is described, with particular emphasis on the principles which guided the design.
A multiprogramming system for process control
Authors: Howry Sam
Published: October 2004

This paper describes an operational small computer multiprogramming system developed for the control of the Stanford Two Mile Linear Accelerator (SLAC). The system has many features of larger systems such as dynamic memory allocation and interprocess control, but does not have to handle typical batch type jobs which need large arrays and many other system resources. This difference results in a drastic reduction in the complexity of both design and implementation. The accelerator control problem is discussed in terms of what requirements are imposed on the system by the environment. Then the basic subsystems are described with sufficient examples to show the reader other areas where such a system may be applicable.
A hardware architecture for implementing protection rings
Authors: Schroeder Michael D. , Saltzer Jerome H.
Published: October 2004

Protection of computations and information is an important aspect of a computer utility. In a system which uses segmentation as a memory addressing scheme, protection can be achieved in part by associating concentric rigns of decreasing access privilege with a computation. The mechanisms allow cross-ring calls and subsequent returns to occur without trapping to the supervisor. Automatic hardware validation of references across ring boundaries is also performed. Thus, a call by a user procedure to a protected subsystem (including the supervisor) is identical to a call to a companion user procedure. The mechanisms of passing and referencing arguments are the same in both cases as well.
Short-term scheduling in multiprogramming systems
Authors: Hansen Per Brinch
Published: October 2004

This paper defines a set of scheduling primitives which have evolved from multiprogramming systems described by Dijkstra, Lampson, Saltzer, and the present author. Compared to earlier papers on the same subject, the present one illustrates a more concise description of operating system principles by means of algorithms. This is achieved by (1) describing the primitives as the instructions of an abstract machine which in turn is defined by its instruction execution algorithm; (2) introducing a notation which distinguishes between the use of synchronizing variables (semaphores) to achieve mutual exclusion of critical sections, and to exchange signals between processes which have explicit input/output relationships; (3) considering the influence of critical sections on preemption and resumption; and (4) using a programming language, Pascal, which includes natural data types (records, classes, and pointers) for the representation of process descriptions and scheduling queues. The algorithms are written at a level of detail which clarifies the fundamental problems of process scheduling and suggests efficient methods of implementation.
Process selection in a hierarchical operating system
Authors: Varney R. C.
Published: October 2004

This paper presents a new model for use in scheduling processes for the sharing of a processor. The model may be used in various modes of operation, including multiprogramming, real time and time sharing. Because the model is applicable for various modes of operation and because it is significantly useful only within a well-defined system hierarchy, the context for discussion is Hansen's system for the RC 4000.
3, 4, 5
Only the preliminary work has been reported in this paper, but the author believes that the model is worth investigating further, and, therefore, research into its effects and properties will continue.
A comparative analysis of disk scheduling policies
Authors: Teorey Toby J. , Pinkerton Tad B.
Published: October 2004

Five well-known scheduling policies for movable head disks are compared using the performance criteria of expected seek time (system oriented) and expected waiting time (individual I/O request oriented). Both analytical and simulation results are obtained. The variance of waiting time is introduced as another meaningful measure of performance, showing possible discrimination against individual requests. Then the choice of a utility function to measure total performance including system oriented and individual request oriented measures is described. Such a function allows one to differentiate among the scheduling policies over a wide range of input loading conditions. The selection and implementation of a maximum performance two-policy algorithm are discussed.
Properties of the working-set model
Authors: Denning Peter J. , Schwartz Stuart C.
Published: October 2004

A program's working set W (t, T) at time t is the set of distinct pages among the T most recently referenced pages. Relations between the average working-set size, the missing-page rate, and the interreference-interval distribution may be derived both from time-average definitions and from ensemble-average (statistical) definitions. An efficient algorithm for estimating these quantities is given. The relation to LRU (least recently used) paging is characterized. The independent-reference model, in which page references are statistically independent, is used to assess the effects of interpage dependencies on working-set size observations. Under general assumptions, working-set size is shown to be normally distributed.
REPOS
Authors: Maegaard Henrik , Andreasen Aksel
Published: October 2004

This paper describes an operating system intended for the low range of the PDP-11 family. The operating system is designed for PDP-1 1's equipped with hardware that facilitate loading of program modules (core-blocks) from a host computer. The operating system is a real time system that supports interrupt handlers and low priority activities. Core-blocks are dynamic in the sense that a core-block can be loaded/removed or relocated while the system is running. Programs may either be written in assembly language or in PASCAL. A PASCAL interface to a PASCAL compiler implemented on the UNIVAC 1100 series is presented.
A set of efficient semaphoring instructions
Authors: Oestreicher Dan , Strauss J. I.
Published: October 2004

A set of instructions is described which facilitates the construction of an operating system implemented as a set of cooperating processes. An unusual feature of the instructions is that they are 'hybrid' -- i.e. they may either operate as conventional machine instructions or give rise to a supervisor - call interrupt, depending on circumstances.
Issues in the design and use of a distributed file system
Authors: Sturgis H. , Mitchell J. , Israel J.
Published: October 2004

This paper discusses an independent file facility, one that is
not
embedded in an operating system. The
distributed file system
(DFS) is so named because it is implemented on a cooperating set of
server
computers connected by a communications, network, which together create the illusion of a single, logical system for the creation, deletion, and random accessing of data. Access to the DFS can only be accomplished over the network; a computer (or, more precisely, a program running on one) that uses the DFS is called a
client
. This paper describes the division of responsibility between servers and clients. The basic tool for maintaining data consistency in these situations is the atomic property of transactions, which protects clients from system malfunctions and from the competing activities of other clients. Several cooperating clients may share a transaction. The DFS provides an unconventional locking mechanism between transactions that supports client caches and eliminates a novel form of deadly embrace. We have implemented and put into service a system based on these concepts.
The concept of asynchronization
Authors: Wettstein H. , Merbeth G.
Published: October 2004

Communication between parallel processes may take place in synchronous or asynchronous form. The former has widely been used in various concepts. In contrast, means for asynchronous process relations exist only in a few systems in rudimentary form. In this paper the concept of asynchronization is developed systematically. The underlying data structures as well as operations upon them are defined for various versions.
User defined files
Authors: Bailey Kirk A. , Boynton Lee , McKenney Paul E. , Oliver Gary J. , Regan Dave
Published: October 2004

In the past, there has been conflict between the application programmer's desire for specialized file types and the system programmer's desire to keep the operating system compact. A solution is proposed that allows a simple file or group of simple files to be encapsulated by a user program. The resulting entity (called a user-defined file) allows arbitrarily complex special-purpose file types to be emulated without continuous modifications to the operating system.
Virtual memory management for database systems
Authors: Traiger Irving L.
Published: October 2004

Over the last several years, a number of hardware and software systems have been developed which map entire files directly into the virtual memory address spaces used by programs. Since all file contents are directly addressable, there is no need for a programmer to issue explicit file system actions, such as Read or Write. In addition, all of the buffer management problems are eliminated, since programmers do not have to squeeze pieces of large files into small virtual spaces. Although these advantages are tempting, we find that database systems have gone their own way. In this paper, we will look at two particular approaches to database system design, and see how (and why) they interface to file systems as they do. We will then look at the potential advantages and implications of working more closely with virtual memory management, and describe some of the functions and constraints that would have to be supported by a generalized page manager.
Mutual exclusion within both software- and hardware-driven kernel primitives
Authors: Harper M. E.
Published: October 2004

Mutual exclusion between process and interrupt-driven execution is normally confined by the designer to passages within the kernel of an operating system and has been implemented traditionally by the judicious use of the interrupt inhibit instruction. This paper illustrates an alternative approach to the problem through the implementation of the conflicting software and hardware-driven kernel primitives as a limited set of concurrent subprocesses sharing a singular kernel domain. Manipulations of kernel data are rendered mutually exclusive through the use of P and V operations on simple semaphores associated with the data objects themselves. The kernel programmer is thereby relieved of real-time considerations in guarding his critical sections and the implementation of the kernel acquires a formalism which can greatly aid its verification, testability and maintainability.
Working sets and near-optimality
Authors: Schmutz H. , Silberbusch P.
Published: October 2004

In [1] Denning concludes from numerous observations of program behaviour that the WS algorithm with a single window size 8 is likely to "deliver throughput typically no worse than 10 percent from optimum". The authors of [2] report about observations of a set of programs, which requires several different window sizes for a i0 percent detuned WS algorithm. The purpose of this short note is to illustrate with the help of simple analysis why the observations reported in [1] were likely in the past and why observations like those of [2] become more and more likely in the future. To this end we introduce the notion of "degree of locality" and show that the locality set size and the degree of locality have impact on the optimal windowsize.
Using personal computers in operating system courses
Authors: Hansen Per Brinch
Published: October 2004

By using personal computers it is now possible to make operating system courses for computer science students as practical as compiler courses. This paper describes a course in which undergraduates use the programming language Edison to build operating systems for IBM Personal Computers.
Why a distributed kernel?
Authors: Kutti Swamy
Published: October 2004

Until now, the design of operating systems assumed the kernel as an extension of a single processor's physical layer supporting user processes in the one cpu. The present multiprocessor operating systems duplicate this set-up in multiple cpus in order to reduce complex inter-processor communication. Since the functions of a kernel in both a uniprocessor and a multiprocessor operating system have a tendency to grow in an unlimited manner, the redesign of both an intelligent and high speed kernel, becomes an important issue. In this paper, I describe firstly, a brief summary of the current status of a kernel, and secondly the future requirements of a complex operating system. Finally, I present part of a possible solution to construct a high speed kernel based on multiple processors.
Resolving covert channels within a B2 class secure system
Authors: Loepere Keith
Published: October 2004

For a secure computer system in the B2, B3 and A1 classes (as defined by the DoD Trusted Computer System Evaluation Criteria), the problem of confining a process such that it may not transmit information in violation of the *-property is an analyzable and solvable problem.This paper examines the problem of covert channels and attempts to analyze and resolve them relative to satisfying the B2 security requirements. A novel solution developed for the Multics computer system for a class of covert channels is presented.
Method for distributed transaction commit and recovery using Byzantine Agreement within clusters of processors
Authors: Mohan C. , Strong R. , Finkelstein S.
Published: October 2004

This paper describes an application of Byzantine Agreement [DoSt82a, DoSt82e, LyFF82] to distributed transaction commit. We replace the second phase of one of the commit algorithms of [MoLi83] with Byzantine Agreement, providing certain trade-offs and advantages at the time of commit and providing speed advantages at the time of recovery from failure. The present work differs from that presented in [DoSt82b] by increasing the scope (handling a general tree of processes, and multi-cluster transactions) and by providing an explicit set of recovery algorithms. We also provide a model for classifying failures that allows comparisons to be made among various proposed distributed commit algorithms. The context for our work is the Highly Available Systems project at the IBM San Jose Research Laboratory [AAF-KM83].
Preliminary thoughts on problem-oriented shared memory
Authors: Cheriton David R.
Published: October 2004

Much of the work to date on distributed systems has focused on the correct choice of
communication paradigm
, stressing (for example) message primitives, remote procedure call, problem- oriented protocols and so on. A distributed system service is then implemented as a module executing on particular server machine that is accessed using these communication facilities. In contrast, the shared
memory paradigm
has been used on multiprocessor and uniprocessor systems. In the shared memory paradigm, the state of a service is stored in shared memory and implemented in a decentralization fashion across multiple processors using this shared memory.This paper describes some preliminary thoughts on applying the shared memory paradigm to distributed systems. For efficiency reasons, shared memory is not provided in its full generality, but only with the semantics required for the applications of interest. This type of application-specific memory is called a
problem-oriented shared memory
. The use of problem- oriented shared memory is illustrated by describing several applications we are exploring in the V distributed system. We also discuss basic requirements on a communication system to support this approach.
Information systems planning: incentives for effective action
Authors: Lederer Albert L. , Mendelow Aubrey L.
Published: October 2004

During two research projects to identify the difficulties associated with information systems planning (ISP), it became apparent that IS managers and users often do not apply a number of commonly accepted guidelines for successful ISP. This paper reports some instances in which the guidelines were not applied. It also explains the neglect of the guidelines in terms of the incentives which the ISP participants had for not applying them. The findings suggest further research and also have practical implications for IS managers.
The integrity problem, and what can be done about it using today's DBMSS
Authors: Honkanen Pentti A.
Published: October 2004

This paper examines the integrity problem in light of what can be accomplished using the syntax of major main-frame DBMSs. The data, entity, and referential integrity problems are examined as they pertain to the relational model. Some suggestions proposed in current literature are examined as a basis for possible solutions. Three major DBMSs, IBM's DB2 (SQL/DS), Cullinet's IDMS/R, and Cincom's Supra are examined and solutions to the data, entity, and referential integrity problems are presented for each system. The proposed solutions cover a spectrum of approaches that could be used in a real world environment. DB2 requires complete individual problem by problem attention by the DBA, IDMS/R requires encoding of constraints by the DBA at schema compilation time, and Supra has system support.
On the Accuracy and Stablility of Clocks Synchronized by the Network Time Protocol in the Internet System
Authors: Mills David L.
Published: October 2004

This paper describes a series of experiments involving over 100,000 hosts of the Internet system and located in the U.S., Europe and the Pacific. The experiments are designed to evaluate the availability, accuracy and reliability of international standard time distribution using the Internet and the Network Time Protocol (NTP), which has been designated an Internet Standard protocol. NTP is designed specifically for use in a large, diverse internet system operating at speeds from mundane to lightwave. In NTP a distributed subnet of time servers operating in a self-organizing, hierarchical, master-slave configuration exchange precision timestamps in order to synchronize host clocks to each other and national time standards via wire or radio.The experiments are designed to locate Internet hosts and gateways that provide time by one of three time distribution protocols and evaluate the accuracy of their indications. For those hosts that support NTP, the experiments determine the distribution of errors and other statistics over paths spanning major portions of the globe. Finally, the experiments evaluate the accuracy and reliability of precision timekeeping using NTP and typical Internet paths involving ARPANET, NSFNET and regional networks. The experiments demonstrate that timekeeping throughout most portions of the Internet can be maintained to an accuracy of a few tens of milliseconds and a stability of a few milliseconds per day, even in cases of failure or disruption of clocks, time servers or networks.
User-level communication based cooperative caching
Authors: Zhang Youhui , Zheng Weimin
Published: October 2004

Cooperative caching is an important element in many distributed systems. However, fewer researches have been focused on how to improve it based on user-level communication technologies that are used more and more widely. This paper presents a user-level communication based caching design, called uniform caching, to decrease the complexity of I/O modules. Uniform caching uses communication memory as the cache directly and employs RDMA (Remote Direct Memory Access) methods to access the remote cache, which can improve access-performance and eliminate data copies between the cache and the communication layer. Our analysis figures out this design can reduce remote-access time about 17.8% than the traditional cooperative caching averagely while the improvement is independent of the cooperative caching algorithm used. Moreover, the prototype of uniform caching on GM has been implemented and achieves a satisfying result.
MADIDS
Authors: Guangchun Luo , Xianliang Lu , Jiong Li , Jun Zhang
Published: October 2004

When traditional IDS (Intrusion Detection System) is used to detect and analyze the great flow data transfer in high-speed network, it usually causes the computation bottleneck. This paper presents a new Mobile Agent Distributed IDS (MADIDS) system basing on the mobile agents. This system is specifically designed to process the great flow data transfer in high-speed network. In MADIDS, the agents that are set at each node process the data transfer by distributed computation. Meanwhile by using the reconfiguration quality of the mobile agents, the load balance of distributed computation can be dynamically implemented to gain the high-performance computing ability. This ability makes the processing of great flow data transfer possible. MADIDS can effectively solve the detection and analysis performance bottleneck caused by the great flow data transfer in high-speed network. And the performance of IDS is enhanced. In this paper, we construct the infrastructure and theoretical analysis model of MADIDS. The deficiencies of MADIDS and future research works are also indicated.
Defining deadlock with fungible resources
Authors: Levine Gertrude Neuman
Published: October 2004

In a previous paper we discussed resource deadlock within a classification of all dead states. We differentiated between the different types of anomalies that are called deadlock in the computer science literature. Our primary aim was to correct inconsistencies that are currently being taught in operating systems' textbooks. We introduced a model that allowed us to precisely define deadlock, but we only provided a partial definition of resource deadlock, which, as we noted, was limited to deadlocks with uniquely identifiable resource units. In response to readers of OSR, we now distinguish between different types of resource deadlock and provide a comprehensive definition. We also suggest that it may be desirable to maintain separate definitions.
Automatic prototype generating via optimized object model
Authors: Liang Sheldon X. , Zhang Lynn , Luqi
Published: October 2004

Computer-aided prototyping shows promise that one system under development frees designers from implementation details by executing specifications via reusable components. Ada is first choice for constructing such reusable object-oriented components because Ada95 is the only international standard programming language that supports object-oriented real-time distributed systems. But Ada has diversified object forms that are so intricate that people feel it difficult to find an equivalence of a class between Java (C++) and Ada95. In computer-aided prototyping, automatic prototype generating is facing one of key problems on how to map a well-defined prototyping specification to an executable prototype with different OOPLs. This paper addresses several key problems in automatic prototype generating with reusable object foundation based on an optimized object model. These problems include transformation of a PSDL specification to the executable system composed from componential object entities, compositional pattern enforcing interactions among components, generalized role wrappers from which physical components can be derived and an optimized object model used to unify different object forms in popular OOPLs.
Real-time programming safety in Java and Ada
Authors: Sandén Bo I.
Published: October 2004

Both Java and the Real-time Specification for Java contain concurrency-related constructs that are easily abused or simply misunderstood by a programmer without sufficient knowledge of multi-threading. This article lists a number of those constructs and shows how they are avoided in Ada. Many of the mistakes arise when a programmer confuses exclusion synchronization and condition synchronization. The article opens with an explanation of those concepts.
Computational geometry column 44
Authors: O'Rourke Joseph
Published: October 2004

The open problem of whether or not every pair of equal-area polygons has a hinged dissection is discussed.
Fault-tolerant computing based on Mach
Authors: Babaoğlu Özalp
Published: October 2004

We consider the problem of providing automatic and transparent fault tolerance to arbitrary user computations based on the Mach operating system. Among the several alternatives for structuring such a system, we pursue the "task-pair backup" paradigm in detail and outline how it might be supported by Mach. Some of the new system calls and protocols that need to be incorporated into the Mach kernel and server tasks are sketched.
IPwatch: a tool for monitoring network locality
Authors: Lorence Mark J. , Satyanarayanan M.
Published: October 2004

In this paper we introduce the concepts of
Logical
and
Physical Network Locality
and point out their importance to the performance of distributed systems. We then describe the design of
IPwatch
, a simple and inexpensive tool for monitoring logical network locality. IPwatch exploits short-term locality to enable monitoring of medium- and long-term locality of large networks using modest computational resources. We describe experiments at Carnegie Mellon University to validate our ideas and to calibrate IPwatch. The results confirm the existence of substantial short-term locality in this environment. Less than 5 percent of the possible host pairs account for 75 percent of the traffic, and less than 15 percent of them account for 90 percent. Comparative measurements on another network in our environment show even stronger short-term locality.
Real-time Ada: outstanding problem areas
Authors: Bums A. , Wellings A. J.
Published: October 2004

As the Ada language matures and compilers be, come more efficient, new application domains will open up. This in turn will place fresh requirements on the language. In some instances Ada, in its current form, will be unsuitable and language changes will be demanded. This is, of course, at odds with producing a "standard" and "stable" language definition; consequently the evolution of the language will be a long and drawn out procedure. The Ada 9X process offers the opportunity to eliminate some of the short-comings of ANSI Ada in the area of real-time systems. It also provides a focus within which the requirements from future real-time systems can be discussed.The purpose of this paper is to identify the outstanding issues that must be discussed in the short, medium or long-term, if Ada is to be used for a wide range of real-time applications in current and future systems. Our approach is to start with application requirements, from these to indicate Ada problem areas and then, if appropriate, offer potential solutions. The areas considered are those associated with hard real-time, software reliability, mode changes, change management and distribution.
Asynchronous communication in Ada
Authors: Elsom Kenneth
Published: October 2004

The current definition of Ada manifestly fails to satisfy the requirements for supporting the application domain characteristics of real-time, embedded and distributed systems particularly with respect to the capability for asynchronous message passing. It is shown that, for a number of independent reasons, the potential for allowing Ada tasks to communicate in this manner by extension of the existing purely synchronous rendezvous has significant benefits. Though this is a radical deviation from the existing language definition a firm proposal is made for allowing asynchronous inter-task communication. Some of the resultant semantic and syntactic implications are explored.
A semantic-based approach to component retrieval
Authors: Sugumaran Vijayan , Storey Veda C.
Published: October 2004

There continues to be a great deal of pressure to design and develop information systems within a short period of time. This urgency has reinvigorated research on software reuse, particularly in component based software development. One of the major problems associated with component-based development is the difficulty in searching and retrieving reusable components that meet the requirement at hand. In part, this problem exists because of the lack of sophisticated query methods and techniques. In this research, a semantic-based approach to component retrieval is presented as a solution to this problem. This approach makes use of domain models containing the objectives, processes, actions, actors, and, an ontology of domain terms, their definitions, and relationships with other domain-specific terms. A reuse repository is developed that contains the components relevant for the creation of new applications, along with their attributes and methods. The natural language interface, domain model, and reusable repository are implemented in a prototype that uses Web and JavaBeans technologies. A sample session is provided for an online auction application to illustrate the usefulness of the proposed approach.
IT acceptance
Authors: Gefen David , Ridings Catherine M.
Published: October 2004

Users and IT personnel typically belong to different organizational units with different objectives and values. This often creates a perceived boundary between the two units, reducing the degree to which users accept the installation of new IT. Much IT research suggests that increased user involvement and influence on IT development can overcome user - IT personnel differences and thereby increase user acceptance. However, the realization of this objective can be problematic when implementing new IT in large organizations within which such user involvement is impractical.This study examines a case of IT adoption in view of Social Identity Theory, which focuses on how identification with groups affects individuals' beliefs and behavior. As hypothesized, users' acceptance of the IT increased when they believed that the inter-group boundary between them and the IT group was reduced and when they believed that they shared values with the IT group. Both of these beliefs increased when the IT group was perceived to be responsive to user requests. The results suggest that, even in large organizations where user influence on IT development is limited, IT group responsiveness can increase user acceptance of new IT.
Implementation and applications of Scott's logic for computable functions
Authors: Milner Robin
Published: October 2004

The basis for this paper is a logic designed by Dana Scott [1] in 1969 for formalizing arguments about computable functions of higher type. This logic uses typed combinators, and we give a more or less direct translation into typed λ-calculus, which is an easier formalism to use, though not so easy for the metatheory because of the presence of bound variables. We then describe, by example only, a proof-checker program which has been implemented for this logic; the program is fully described in [2]. We relate the induction rule which is central to the logic to two more familiar rules - Recursion Induction and Structural Induction - showing that the former is a theorem of the logic, and that for recursively defined structures the latter is a derived rule of the logic. Finally we show how the syntax and semantics of a simple programming language may be described completely in the logic, and we give an example of a theorem which relates syntactic and semantic properties of programs and which can be stated and proved within the logic.
Derivation of axiomatic definitions of programming languages from algorithmic definitions
Authors: Allen C David
Published: October 2004

Language definitions by abstract interpreters are appropriate to the design and development of a language. Axiomatic definitions are more appropriate to proving program properties and verification of compilers. The proof methods of Manna and Ashcroft can be applied to an algorithmic definition in, e.g. the Vienna Definition Language to deduce theorems which constitute an axiomatic definition of precisely the same language.

The process and techniques are explained, and illustrated on a simple language of assignment statements.
Recursive definitions of partial functions and their computations
Authors: Cadiou J. M. , Manna Zohar
Published: October 2004

The object of this paper is to present a syntactic and semantic model for recursive definitions, and to study the relation between their computed functions and their fixpoints. The recursive definitions that we consider are syntactic generalizations of those introduced in [2] by Kleene and in [5] by McCarthy.

Each recursive definition yields two classes of fixpoint partial functions (“fixpoints over D υ {ω}” and “fixpoints over D”), and a class of computed partial functions obtained by applying different computation rules to the recursive definition. In this work we first describe the relations between the computed functions and the fixpoints over D υ {ω} (Theorem 1), and between the computed functions and the fixpoints over D (Theorem 2). Our main interest is in the class of fixpoints (over D or D υ {ω}) which are also computed functions of the recursive definition.
The correctness of numerical algorithms
Authors: Hull T. E. , Enright W. H. , Sedgwick A. E.
Published: October 2004

Structured programming and the use of assertions are two basic techniques needed in organizing proofs of the correctness of algorithms. These techniques can be combined with theorems in numerical analysis to produce proofs of the correctness of numerical algorithms.

A simple algorithm for finding the sum of n numbers is first used to show how assertions can be modified to take account of the effect of roundoff. A so-called backward error analysis then leads to a proof that the algorithm is correct in the sense that it produces exact results for slightly perturbed problems. Alternative points of view are possible, and one of the distinguishing features of numerical algorithms is that there usually are a number of different senses in which one might want to prove them correct.

Two other more substantial algorithms, one for solving linear algebraic equations and one for solving differential equations, are then used to show how structured programming and the use of assertions can be combined with error analyses of fairly complicated numerical processes to provide proofs of correctness. One of these algorithms involves roundoff error while the other is affected primarily by truncation error.
Lambda calculus schemata
Authors: Fischer Michael J.
Published: October 2004

A lambda calculus schema is an expression of the lambda calculus augmented by uninterpreted constant and function symbols and thus is an abstraction of programming languages such as LISP which permit functions to be passed to or returned from other functions. We then consider two natural implementation strategies: the retention strategy in which all variable bindings are retained until no longer needed (implying the use of some sort of garbage collected store) and the deletion strategy, modelled after the usual stack implementation of ALGOL-60, in which variable bindings are destroyed when control leaves the procedure (or block) in which they were created. Berry shows that the deletion strategy implementation is not “correct” for a wide class of languages in the sense that it is not equivalent to natural extensions of the copy rule of ALGOL to such languages, whereas the retention strategy is correct in that sense. We show, however, that no real power is lost in restricting oneself to a deletion strategy implementation, for any program can be translated into an equivalent one which will work correctly under such an implementation. The proof makes no use of the particular primitive functions and data of the language and hence is true of the corresponding schemata under all interpretations.
Calculating properties of programs by valuations on specific models
Authors: Sintzoff Michel
Published: October 2004

The proof that a program verifies some property is carried out by the valuation of the program in a model characterizing that property. Specific models are given for sufficient conditions of the correctness of types, locations and asynchronous computations; a hypothetical programming language is used, which includes functions and locations and allows their recursive composition. The application of the method in studying termination or correctness problems is discussed on particular programs.
A plan for producing a conventional Ada library
Authors: Condic Marin D.
Published: October 2004

There is a general consensus that Ada would benefit from having a library of tools available that would be standard across most or all implementations. This paper discusses how to get a "standard" l ibrary for Ada without impacting the ARM, increasing the leverage available to Ada developers, providing an enhanced product for the Ada compiler vendors, sparking new interest in Ada and perhaps building a financially successful business in the process.
Resource management in large distributed systems
Authors: Goscinski Andrzej , Bearman Mirion
Published: October 2004

In this paper, we propose that a resource management system for large distributed systems should have two levels --- a lower one, responsible for export and allocation of resources in local distributed systems, and an upper one, which manages special resources/services that are not provided locally. For a local environment, load balancing (implementing export and allocation of computational resources) is realized in a distributed way; and management of peripheral resources is developed based on a name server, which can be centralized, or distributed and replicated. The upper level has a centralized resource management center, which is responsible for export and allocation of both peripheral and computational resources. It contains two parts: a name server, which stores attributed names of all shareable resources and a resource manager, which allocates resources to requesting users of a large distributed system. Communication between the resource management center and the local systems is facilitated through integrating modules. This system is now designed based on the RHODOS distributed operating system.
A model for intelligent task scheduling in a large distributed system
Authors: Jun Chen , Li Xie , Zhong-xiu Sun
Published: October 2004

Most existing task scheduling algorithms will lose efficiency in a large distributed system because of the uncertainty, incompleteness, and instability problems. This paper proposes a concept of in telligent distributed task scheduling IDTS to solve these problems.
Implementation of in-house developed vs application package based information systems
Authors: Iivari J.
Published: October 2004

Even though in-house development and the use of application packages form two major strategies for developing information systems, there is practically no research into the comparative implementability of information systems developed according to these strategies. The article suggests that the level or originality of information systems can be used as a theoretical concept underlying the dichotomy of in-house development vs. application packages, and puts forward a set of hypotheses regarding the influence of the level of originality on the implementability of information systems. The hypotheses form the theoretical basis for a comparison of the two types of information system development in terms of implementability, and clearly support Lynch's finding (Lynch, 1984) that the implementation of application packages is more difficult than one might initially expect.
Information delivery systems in the 1990's: the Local INtegrated Knowledge NETwork (LINKNET)
Authors: Straub Detmar W. , Beath Cynthia Mathis
Published: October 2004

In the late 80's, managers, professionals, analysts, and researchers are finding it increasingly difficult to manage the vast array of data and text that are available to them. The fragmentation in media and sources of information, and discontinuities between the information bureaucracies, particularly Information Systems and the library, hinder ready access to information. In the future, this paper argues, a department-level Local INtegrated Knowledge NETwork (LINKNET), will help individuals locate and integrate needed information. The LINKNET environment as conceived here consists of data and human resources at departmental locations that constitute a technological and organizational infrastructure for information delivery. In particular it makes available those information technologies specializing in information integration--integrative software, sharable resources like computerized storage devices, and information collections--and essential human resources like information resource management, consulting, and training.