waashk/acm huggingface dataset:
joint actions based authorization schemes authorization policy requirements in commercial applications are often richer compared to military applications in terms of the types of privileges required, and more complex in terms of both the nature and degree of interactions between participating objects. delegation and joint action mechanisms allow a more flexible and dynamic form of access control, thereby enabling the representation of sophisticated authorization policies. this paper explores some issues that need to be addressed when designing such joint actions based authorization policies. we describe some approaches to supporting joint actions based authorization policies, and their ramifications for trust of various components of the implementation. we consider an example from the medical field, and define attributes relevant to the design of joint action schemes and present three schemes for supporting joint action based authorization policies. vijay varadharajan phillip allen
reimplementing the cedar file system using logging and group commit  the workstation file system for the cedar programming environment was modified to improve its robustness and performance. previously, the file system used hardware-provided labels on disk blocks to increase robustness against hardware and software errors. the new system does not require hardware disk labels, yet is more robust than the old system. recovery is rapid after a crash. the performance of operations on file system metadata, e.g., file creation or open, is greatly improved.  the new file system has two features that make it atypical. the system uses a log, as do most database systems, to recover metadata about the file system. to gain performance, it uses group commit, a concept derived from high performance database systems. the design of the system used a simple, yet detailed and accurate, analytical model to choose between several design alternatives in order to provide good disk performance.  r. hagmann
ubiquitous applications: embedded systems to mainframe  over the last 10 years, smalltalk has moved from the "parc" to main street as a standard object-oriented (oo) fifth generation language (5gl) for enterprise computing. to meet the needs of application developers, smalltalk environments and tools have matured from the original research implementations to full- featured, multiplatform development environments. a recent study of development tools conducted by software productivity research in massachusetts for a software productivity consortium ranked smalltalk first in most categories. what is surprising about this study is the application: a demanding telephone switch traditionally dominated by c or proprietary talc languages such as chill, protel, and plex. the fact that smalltalk ranked so highly is a testimony that smalltalk is an application 5gl that scales. this article discusses the major technical challenges addressed by smalltalk implementors and application developers working on a wide spectrum of applications.  dave thomas
source-to-source translation: ada to pascal and pascal to ada  an implementation of translators between ada and pascal is described. the method used is to define subsets of each language between which there is a straightforward translation and to translate each source program to its respective sublanguage by program transformations. a common internal tree representation is used. the underlying organization of the translators is described, and some of the difficulties we have confronted and solved are discussed.  paul f. albrecht phillip e. garrison susan l. graham robert h. hyerle patricia ip bernd krieg bruckner
bruwin  with only one process viewable and operational at any moment, the standard terminal forces the user to continually switch between contexts. yet this is unnatural and counter-intuitive to the normal working environment of a desk where the worker is able to view and base subsequent actions on multiple pieces of information.  the window manager is an emerging computing paradigm which allows the user to create multiple terminals on the same viewing surface and to display and act upon these simultaneous processes without loss of context. though several research efforts in the past decade have introduced window managers, they have been based on the design or major overhaul of a language or operating system; the window manager becomes a focus of---rather than a tool of---the system. while many of the existing implementations provide wide functionality, most implementations and their associated designs are not readily available for common use; extensibility is minimal.  this paper describes the design and implementation of bruwin, the brown university window manager, stressing how such a design can be adapted to a variety of computer systems and output devices, ranging from alphanumeric terminals to high-resolution raster graphics displays. the paper first gives a brief overview of the general window manager paradigm and existing examples. next we present an explanation of the user-level functions we have chosen to include in our general design. we then describe the structure and design of a window manager, outlining the five important parts in detail. finally, we describe our current implementation and provide a sample session to highlight important features.  norman meyrowitz margaret moser
data encapsulation using fortran 77 modules  traditionally, the preferred method for developing numerical models in the fortran language, as standardized in 1977, has been the top-down structured approach. this method emphasizes the relation between procedures necessary to solve a particular programming problem. an alternative perspective is to consider data and manipulation of data fundamental to solution of a programming problem. a programming construct arising from this perspective may be termed a module. a module is comprised of a set of procedures and data they manipulate. modules may be used to encapsulate data, that is, hide module data from and prevent their direct use by routines outside the module. information computed from module data is obtained indirectly through invocation of procedures. modules, comprised of associated groups of data and respective procedures, provide program structure beyond that available using procedural- oriented practices alone. construction and use of modules potentially improves program clarity, reduces argument passing, and encapsulates data at the level where they are manipulated. use of fortran 77 modules, like the use of top- down structured programming, is a programming techique allowed but not supported or enforced by the fortran 77 language. consequently, successful implementation of modules with fortran 77 and realization of potential benefits depend on voluntary adherence to the programming technique. use of other computer languages (such as modula-2, ada, c++, and fortran 90) which, to varying degrees, support or enforce programming techniqes similar to the use of fortran 77 modules might significantly increase programming efficiency and realization of potential benefits.  lewis l. delong david b. thompson janice m. fulford
analysis of function applications in deep arrays  function arrays are easy to understand in apl when the leaves are primitive scalar functions. herein other kinds of functions, called generically subscalars, are studied as items in functions arrays. some example primitive shave an internal analog of structure. they are explicated using an experimental depth operator and some defined subprimitive functions. subscalar leaves of function arrays interrupt the promulgation of scalar conformance in a resumable fashion reminiscent of the data types of kajiya [6].  j. philip benkard
performance evaluation of concurrent systems using timed petri nets  it is shown that the behavior of petri nets with exponentially distributed firing times can be represented by labeled directed "state" graphs in which labels describe the probabilities of transitions between vertices of the graph. for bounded petri nets the corresponding state graphs are finite, and are isomorphic to finite state markov chains, stationary descriptions can thus be obtained by standard techniques. an immediate application of such a model is performance analysis of concurrent systems, and in particular queueing systems with exponentially distributed arrival and service times. a simple example of an interactive computer system model is used as an illustration of performance evaluation.  wlodzimierz m. zuberek
run-time check elimination for ada 9x  an approach to the elimination of run-time checks in ada 9x is presented. the approach is a flow analysis approach based on a combination of range propagation and assertion propagation. range propagation computes estimates for the dynamic characteristics of program entities, for example the values of objects, while assertion propagation maintains valid assertions derived from assignments and conditions of the program. this approach offers a simple alternative to the more complex approach of a theorem prover.  peter lutzen moller
a prototype approach to instrument network software (abstract only)  this paper presents the prototype approach used in the development of a distributed instrumentation network and the benefits derived from it. each node in the network is a dedicated microcomputer which is used for instrument control, data acquisition, and preliminary data analysis. data is saved on a mass storage at the control node. general purpose interface bus (ieee488) is used in the network. a prototype was developed primarily to study the feasibility of the system and get user recommendation for change in requirements. due to inherent characteristics of this language the prototype was compact and the development was fast. only two of the seven nodes were included in the prototype. due to the success of the prototype the actual system is currently being developed. the prototype was helpful in several ways. many of the techniques used in the prototype are adapted to the actual system, which is in a different computer and language. in a small scale project with low staffing and tight time schedules this is found to be a more practical approach.  this work is supported by doe contract de-ac02-80et15601.  thomas philip
safety checking of machine code  we show how to determine statically whether it is safe for untrusted machine code to be loaded into a trusted host system.  our safety-checking technique operates directly on the untrusted machine-code program, requiring only that the initial inputs to the untrusted program be annotated with typestate information and linear constraints. this approach opens up the possibility of being able to certify code produced by any compiler from any source language, which gives the code producers more freedom in choosing the language in which they write their programs. it eliminates the dependence of safety on the correctness of the compiler because the final product of the compiler is checked. it leads to the decoupling of the safety policy from the language in which the untrusted code is written, and consequently, makes it possible for safety checking to be performed with respect to an extensible set of safety properties that are specified on the host side.  we have implemented a prototype safety checker for sparc machine-language programs, and applied the safety checker to several examples. the safety checker was able to either prove that an example met the necessary safety conditions, or identify the places where the safety conditions were violated. the checking times ranged from less than a second to 14 seconds on an ultrasparc machine.  zhichen xu barton p. miller thomas reps
prevention of task overruns in real-time non-preemptive multiprogramming systems  real-time multiprogramming systems, in which a hardware processor is dynamically assigned to run multiple software processes each designed to control an important device (user), are considered. each software process executes a task in response to a service request repeatedly coming from the corresponding user. each service task is associated with a strict deadline, and thus the design problem that we are concerned with is to ensure that the service tasks requested can always be executed within the associated deadlines, i.e., no task overrun occurs. this problem was studied by several investigators for the cases where preemptive scheduling strategies are used. in contrast, very few studies have been conducted for cases of non-preemptive scheduling. in this paper we show that a non-preemptive strategy, called relative urgency non-preemptive (runp) strategy, is optimal in the sense that if a system runs without a task overrun under any non-preemptive strategy, it will also run without a task overrun under the runp strategy. then an efficient procedure used at the design time for detecting the possibility of a task overrun in a system using the runp strategy is presented. the procedure is useful in designing overrun-free real-time multiprogramming systems that yield high processor utilizations. some special types of systems using the runp strategy for which even simpler detection procedures are available are also discussed.  k. h. kim mahmoud naghibzadeh
automated application programming environment  with the availability of high-performance, low-cost hardware, apl provides a cost-effective means of developing custom software for the small business environment, and perhaps the best alternative to trying to adapt to an off- the-shelf package. since apl does not inherently deal with system specific screen manipulation and file management techniques, programming these interface requirements from apl is typically tedious, potentially reducing the attractiveness of apl as the development language. strategies for dealing with the realities of screen and file management in the context of small business systems are discussed in this paper. low level functions with universal application are described along with code generation utilities to automatically produce the user and file interfaces for application packages. the programmer makes use of the screen and file management utilities to specify screen i/o and file management requirements resulting in a set of automatically generated screen and file functions for use with the application program. thus, the programmer is relieved of the tedious task of dealing with the programming of the user and file interfaces and can concentrate on the "core" of the application program. furthermore, system specific code in the application program (for displays and files) minimally affects portability since the utilities confine such code to a handful of low level functions. a working example of a small business system constructed with the assistance of screen and file management utilities is discussed.  yap s. chua charles n. winton
a framework for event-based software integration  although event-based software integration is one of the most prevalent approaches to loose integration, no consistent model for describing it exists. as a result, there is no uniform way to discuss event-based integration, compare approaches and implementations, specify new event-based approaches, or match user requirements with the capabilities of event-based integration systems. we attempt to address these shortcomings by specifying a generic framework for event-based integration, the ebi framework, that provides a flexible, object-oriented model for discussing and comparing event- based integration approaches. the ebi framework can model dynamic and static specification, composition, and decomposition and can be instantiated to describe the features of most common event-based integration approaches. we demonstrate how to use the framework as a reference model by comparing and contrasting three well-known integration systems: field, polylith, and corba.  daniel j. barrett lori a. clarke peri l. tarr alexander e. wise
dynamic priorities, priority scheduling and priority inheritance  scheduling requirements are a major portion of the set of requirements that must be addressed by the ada 9x project. this is evident by the numerous revision requests (rrs) submitted (over 25) to the ada 9x project office and the subsequent revision issues (ri-7005 and ri-7007). the related 9x requirements are:    * r1 - flexible scheduling   * r2 - flexible entry queue ordering   * ir2 - rendezvous performance   * ir3 - extended priority support   * wr1 - flexible select algorithm  this report summarizes the workshop's discussions on this important area. the discussions first considered dynamic priorities, and then priority scheduling and priority inheritance.  fred maymir-ducharme
adaptable, reusable code  this paper discusses the concept of adaptability as a means for reaping the cost and schedule reduction benefits of reuse. adaptability strives to implement the variability identified by domain analyses while managing the cost of implementation, extension, and use. the paper discusses a context for understanding different domain-specific reuse approches relative to adaptability and analyzes experience in designing and developing adaptable code. the experience is drawn from the arpa software technology for adaptable, reliable systems (stars) joint demonstration project with u.s. navy.  margaret j. davis
generic virtual memory management for operating system kernels  we discuss the rationale and design of a generic memory management interface, for a family of scalable operating systems. it consists of a general interface for managing virtual memory, independently of the underlying hardware architecture (e.g. paged versus segmented memory), and independently of the operating system kernel in which it is to be integrated. in particular, this interface provides abstractions for support of a single, consistent cache for both mapped objects and explicit i/o, and control of data caching in real memory. data management policies are delegated to external managers.  a portable implementation of the generic memory management interface for paged architectures, the paged virtual memory manager, is detailed. the pvm uses the novel history object technique for efficient deferred copying. the gmi is used by the chorus nucleus, in particular to support a distributed version of unix. performance measurements compare favorably with other systems.  e. abrossimov m. rozier m. shapiro
static evaluation of functional programs  static evaluation underlies essentially all techniques for a priori semantic program manipulation, i.e. those that stop short of fully general execution. included are such activities as type checking, partial evaluation, and, ultimately, optimized compilation.  this paper describes a novel approach to static evaluation of programs in functional languages involving infinite data objects, i.e. those using normal order or "lazy" evaluation. its principal features are abstract interpretation on a domain of demand patterns, and a notion of function "reversal". the latter associates with each function f a derived function f' mapping demand patterns on f to demand patterns on its formal parameter. this is used for a comprehensive form of strictness analysis, aiding in efficient compilation.  this analysis leads to a revised notion of basic block, appropriate as an intermediate representation for a normal order functional language. an implementation of the analysis technique in prolog is sketched, as well as an effort currently underway to apply the technique to the generation of optimized g-machine code.  gary lindstrom
garbage collection of timestamped data in stampede  stampede is a parallel programming system to facilitate the programming of interactive multimedia applications on clusters of smps.  in a stampede application, a variable number of threads can communicate data items to each other via channels, which are distributed, synchronized data structures containing timestamped data such as images from a video camera. channels are not queue-like: threads may produce and consume items out of timestamp order; they may produce and consume items sparsely (skipping timestamps), and multiple threads (including newly created threads) may consume an item in a channel. these flexibilities are required due to the complex dynamic parallel structure of applications, to support increased parallelism, and because of real-time requirements.  under these circumstances, a key issue is the "garbage collection condition": when can an item in a channel be garbage collected?  in this paper we specify precisely stampede's semantics concerning timestamps, and we describe two associated garbage collection conditions& a weak condition, and a more expensive but stronger condition. we then describe a distributed, concurrent algorithm that implements these two gc conditions. we present performance numbers that show little or no application-level performance penalty to using this algorithm for aiding automatic garbage collection in a cluster. we conclude with some remarks about the implementation in the stampede system.  rishiyur s. nikhil umakishore ramachandran
using perturbation analysis to measure variation in the information content of test sets we define the information content of test set t with respect to a program p to be the degree to which the behavior of p on t approximates the overall behavior of p. informally, the higher the information content of a test set, the greater the likelihood an error in the data state of a program will be manifested under testing.perturbation analysis injects errors into the data state of an executing program and traces the impact of those errors on the intervening states and the program's output. the injection is performed by perturbation functions that randomly change the program's data state. using perturbation analysis we demonstrate that different test sets may satisfy the same testing criterion but have significantly different information content.we believe that "consistency of information content" is a crucial measure of the quality of a testing strategy. we show how perturbation analysis may be used to assess individual testing strategies and to compare different testing strategies.the "coupling effect" of mutation testing implies that there is little variation among mutation-adequate test sets for a program. this implication is investigated for two simple programs by analyzing the variation among several mutation-adequate test sets. larry morell branson murrill
supporting the restructuring of data abstractions through manipulation of a program visualization  with a meaning-preserving restructuring tool, a software engineer can change a program's structure to ease future modifications. however, deciding how to restructure the program requires a global understanding of the program's structure, which cannot be derived easily by directly inspecting the source code. we describe a manipulable program visualization---the star diagram\\---that supports the restructuring task of encapsulating a global data structure. the star diagram graphically displays information pertinent to encapsulation, and direct manipulation of the diagram causes the underlying program to be restructured. the visualization compactly presents all statements in the program that use the given global data structure, helping the programmer to choose the functions that completely encapsulate it. additionally, the visualization elides code unrelated to the data structure and to the task and collapses similar expressions to help the programmer identify frequently occurring code fragments and manipulate them together. the visualization is mapped directly to the program text, so manipulation of the visualization also restructures the program. we present the star diagram concept and describe an implementation of the star diagram built upon a meaning-preserving restructuring tool for scheme. we also describe our creation of star diagram generators for c programs, and we test the scalability of the star diagram using large c and mumps programs.  robert w. bowdidge william g. griswold