waashk/acm huggingface dataset:
the design and implementation of an intentional naming system this paper presents the design and implementation of the intentional naming system (ins), a resource discovery and service location system for dynamic and mobile networks of devices and computers. such environments require a naming system that is (i) expressive, to describe and make requests based on specific properties of services, (ii) responsive, to track changes due to mobility and performance, (iii) robust, to handle failures, and (iv) easily configurable. ins uses a simple language based on attributes and values for its names. applications use the language to describe what they are looking for (i.e., their _intent_), not where to find things (i.e., not hostnames). ins implements a _late binding_ mechanism that integrates name resolution and message routing, enabling clients to continue communicating with end-nodes even if the name-to-address mappings change while a session is in progress. ins resolvers self-configure to form an application- level overlay network, which they use to discover new services, perform late binding, and maintain weak consistency of names using soft-state name exchanges and updates. we analyze the performance of the ins algorithms and protocols, present measurements of a java-based implementation, and describe three applications we have implemented that demonstrate the feasibility and utility of ins. william adjie-winoto elliot schwartz hari balakrishnan jeremy lilley
architectural issues in software reuse: it's not just the functionality, it's the packaging  effective reuse depends not only on finding and reusing components, but also on the ways those components are combined. the informal folklore of software engineering provides a number of diverse styles for organizing software systems. these styles, or architectures, show how to compose systems from components; different styles expect different kinds of component packaging and different kinds of interactions between the components. unfortunately, these styles and packaging distinctions are often implicit; as a consequence, components with appropriate functionality may fail to work together. this talk surveys common architectural styles, including important packaging and interaction distinctions, and proposes an approach to the problem of reconciling architectural mismatches.  mary shaw
libraries as programs preserved within compiler continuations  an approach to library organization for block-structured languages is given that avoids corrupting such structuring with the introduction of "modules", "units", or "packages". the scheme involves retentive block structuring and the preservation of partially compiled programs as compiler continuations. its chief advantage is language simplicity. its chief disadvantage is, at the present, its proclivity towards redundant file storage. this can possibly be eliminated by adopting a computational model using a one-level store.  mark b. wells margaret a. hug rollo silver
definitions of dependence distance  data dependence distance is widely used to characterize data dependences in advance optimizing compilers. the standard definition of dependence distance assumes that loops are normalized (have constant lower bounds and a step of 1); there is not a commonly accepted definition for unnormalized loops. we have identified several potential definitions, all of which give the same answer for normalized loops. there are a number of subtleties involved in choosing between these definitions, and no one definition is suitable for all applications.  william pugh
the finalization operation for abstract types  in this paper we argue the importance of a finalization capability in a programming language abstract type facility. finalization, the dual of initialization, is crucial for applications involving the allocation of, and access to, abstract resources. a semantic model for finalization is given, defining both statically and dynamically allocated abstract objects, in the presence of exception handling. for illustration, we incorporate finalization in an abstract data type facility designed as an extension of ada.  richard l. schwartz p. m. melliar-smith
combining generational and conservative garbage collection: framework and implementations  two key ideas in garbage collection are generational collection and conservative pointer-finding. generational collection and conservative pointer-finding are hard to use together, because generational collection is usually expressed in terms of copying objects, while conservative pointer- finding precludes copying. we present a new framework for defining garbage collectors. when applied to generational collection, it generalizes the notion of younger/older to a partial order. it can describe traditional generational and conservative techniques, and lends itself to combining different techniques in novel ways. we study in particular two new garbage collectors inspired by this framework. both these collectors use conservative pointer- finding. the first one is based on a rewrite of an existing trace-and-sweep collector to use one level of generation. the second one has a single parameter, which controls how objects are partitioned into generations: the value of this parameter can be changed dynamically with no overhead. we have implemented both collectors and present measurements of their performance in practice.  alan demmers mark weiser barry hayes hans boehm daniel bobrow scott shenker
a formal model and specification language for procedure calling conventions  procedure calling conventions are used to provide uniform procedure- call interfaces. applications, such as compilers and debuggers, which generate, or process procedures at the machine-language abstraction level require knowledge of the calling convention. in this paper, we develop a formal model for procedure calling conventions called p-fsa's. using this model, we are able to ensure several completeness and consistency properties of calling conventions. currently, applications that manipulate procedures implement conventions in an ad-hoc manner. the resulting code is complicated with details, difficult to maintain, and often riddled with errors. to alleviate the situation, we introduce a calling convention specification language, called ccl. the combination of ccl and p-fsa's facilitates the accurate specification of conventions that can be shown to be both consistent and complete.  mark w. bailey jack w. davidson
a trace transformation technique for communication refinement  models of computation like kahn and dataflow process networks provide convenient means for modeling signal processing applications. this is partly due to the abstract primitives that these models offer for communication between concurrent processes. however, when mapping an application model onto an architecture, these primitives need to be mapped onto architecture level communication primitives. we present a trace transformation technique that supports a system architect in performing this communication refinement. we discuss the implementation of this technique in a tool for architecture exploration named spade and present examples.  paul lieverse pieter van der wolf ed deprettere
principles of package design  subprogram packages are groups of related subroutines used to extend the available facilities in a programming system. the results of developing several such packages for various applications are presented, with a distinction made between external and internal design criteria--- what properties packages should offer to their users and the guidelines designers should follow in order to provide them. an important issue, the design of reusable software, is thus addressed, and the concept of abstract data types proposed as a desirable solution.  bertrand meyer
problems with pthreads and ada  this position paper discusses issues related to the recent effort to add real- time extensions to the posix (1003.1 |3|) standard, and in particular to the proposal for light-weight tasking in the form of pthreads |2|. it is claimed that this effort is relevant to the ada community, especially in the real-time domain. while offering great opportunities to improve the performance of multi-tasking, real-time ada applications, it may become not useful if the semantics of the specifications are not thought about very carefully, and the match with ada requirements is not satisfied. due to certain problems with the proposal as it stands now, it is suggested that the workshop take a close look at the draft, evaluate it, and decide on a plan of action to guarantee the suitability of pthreads to real-time ada applications before it is approved as a standard.  offer pazy
language constructs for managing change in process-centered environments  change is pervasive during software development, affecting objects, processes, and environments. in process centered environments, change management can be facilitated by software-process programming, which formalizes the representation of software products and processes using software-process programming languages (sppls). to fully realize this goal sppls should include constructs that specifically address the problems of change management. these problems include lack of representation of inter- object relationships, weak semantics for inter-object relationships, visibility of implementations, lack of formal representation of software processes, and reliance on programmers to manage change manually.  appl/a is a prototype sppl that addresses these problems. appl/a is an extension to ada.. the principal extensions include abstract, persistent relations with programmable implementations, relation attributes that may be composite and derived, triggers that react to relation operations, optionally- enforceable predicates on relations, and five composite statements with transaction-like capabilities.  appl/a relations and triggers are especially important for the problems raised here. relations enable inter-object relationships to be represented explicitly and derivation dependencies to be maintained automatically. relation bodies can be programmed to implement alternative storage and computation strategies without affecting users of relation specifications. triggers can react to changes in relations, automatically propagating data, invoking tools, and performing other change management tasks. predicates and the transaction-like statements support change management in the face of evolving standards of consistency. together, these features mitigate many of the problems that complicate change management in software processes and process-centered environments.  stanley m. sutton dennis heimbigner leon j. osterweil
the class concept in the simula programming language  this paper is directed at apl-users who wants a quick introduction into the main features of the simula programming language. simula is a general purpose high-level language. good simula systems exist on most large computers. the paper describes the methods for program and data structuring in simula. these are well suited for structured programming and for the production of secure, modular programs. the paper also points at some major differences between simula and apl.  jacob palme mats wallin
the new developments in c  the c language has developed considerably since the publication of the kernighan and ritchie book. the language development includes enumeration data types, a void type, long (more than 8 character) identifiers, and an expanded semantic structure. at the same time, the compiler technology that developed the portable c compiler (which was used to provide more than 30 production compilers on different machines) is evolving into pcc2, which offers improved maintenance and an easier porting process while handling a larger number of machine features.  s. c. johnson l. rosler
debugging concurrent programs  the main problems associated with debugging concurrent programs are increased complexity, the "probe effect," nonrepeatability, and the lack of a synchronized global clock. the probe effect refers to the fact that any attempt to observe the behavior of a distributed system may change the behavior of that system. for some parallel programs, different executions with the same data will result in different results even without any attempt to observe the behavior. even when the behavior can be observed, in many systems the lack of a synchronized global clock makes the results of the observation difficult to interpret. this paper discusses these and other problems related to debugging concurrent programs and presents a survey of current techniques used in debugging concurrent programs. systems using three general techniques are described: traditional or breakpoint style debuggers, event monitoring systems, and static analysis systems. in addition, techniques for limiting, organizing, and displaying a large amount of data produced by the debugging systems are discussed.  charles e. mcdowell david p. helmbold
the design and implementation of home  home is a version of smalltalk which can be efficiently executed on a multiprocessor and can be executed in parallel by combining a smalltalk process with a mach thread and executing the process on the thread. home is nearly the same as ordinary smalltalk except that multiple processes may execute in parallel. thus, almost all applications running on ordinary smalltalk can be executed on home without changes in their code.  home was designed and implemented based on the following fundamental policies: (1) theoretically, an infinite number of processes can become active; (2) the moment a process is scheduled, it becomes active; (3) no process switching occurs; (4) home is equivalent to ordinary smalltalk except for the previous three policies.  the performance of the current implementation of home running on omron luna-88k, which had four processors, was measured by benchmarks which execute in parallel with multiple processes. in all benchmarks, the results showed that home's performance is much better than hps on the same workstation.  kazuhiro ogata satoshi kurihara mikio inari norihisa doi
effective partial redundancy elimination  partial redundancy elimination is a code optimization with a long history of literature and implementation. in practice, its effectiveness depends on issues of naming and code shape. this paper shows that a combination of global reassociation and global value numbering can increase the effectiveness of partial redundancy elimination. by imposing a discipline on the choice of names and the shape of expressions, we are able to expose more redundancies.  as part of the work, we introduce a new algorithm for global reassociation of expressions. it uses global information to reorder expressions, creating opportunities for other optimizations. the new algorithm generalizes earlier work that ordered fortran array address expressions to improve otpimization [25].  preston briggs keith d. cooper
interesting problems in transforming existing software for reusability  this paper discusses some of the technical problems encountered in the automated transformation of ada software to improve its ability to be reused in other systems. it also presents approaches for addressing those problems. the specific transformations covered in this paper are:  • replacing visible data structures with private types  • converting non- generic units into generic units  • extracting abstract data type (adt) packages  • replacing pre- defined typed with user-defined types  • parameterizing references to global variables  for each transformation, the paper provides rationale for making the change, a description with examples showing how the code is changed, a discussion of potential problems in achieving a useful result, and decisions made for its implementation using an automated tool called the re-engineering mentor. despite the technical challenges presented by these and other automated transformations of ada software, the paper shows that significant improvements in the reusability of existing code can be achieved in a cost-effective manner.  kathleen gilroy
a discriminant metric for module cohesion  the decomposition of a large program into modules can be guided by the use of a property called cohesion, first described by constantine. cohesion is a quality that describes the degree to which the different actions performed by a module contribute to a unified function. however, this technique may be difficult to apply due to the subjective nature of the definitions of levels of cohesion. in this paper a software metric is defined and proposed as a discriminant for classifying modules according to their cohesion. formal properties of the metric are derived which can be used to set the metric value ranges for module classification.  thomas j. emerson
spam: a microcode based tool for tracing operating system events  we have developed a tool called spam (for system performance analysis using microcode), based on microcode modifications to a vax 8600, that traces operating system events as a side-effect to normal execution. this trace of interrupts, exceptions, system calls and context switches can then be processed to analyze operating system behavior for the purpose of debugging, tuning or development. spam allows measurements to be made on a fully operating unix system with little perturbation (typically less than 10%) and without the need for modifying the kernel.  stephen w. melvin yale n. patt
process decomposition through locality of reference  in the context of sequential computers, it is common practice to exploit temporal locality of reference through devices such as caches and virtual memory. in the context of multiprocessors, we believe that it is equally important to exploit spatial locality of reference. we are developing a system which, given a sequential program and its domain decomposition, performs process decomposition so as to enhance spatial locality of reference. we describe an application of this method - generating code from shared-memory programs for the (distributed memory) intel ipsc/2.  a. rogers k. pingali
reliable, reusable ada components for constructing large, distributed multi- task networks: networks architecture services (nas)  this paper will introduce the key concepts of trw's reusable message based design software (network architecture services- nas) which has proven to be key to the ccpds-r project's progress to date. the nas software and supporting tools have provided the ccpds-r project team with reliable, powerful building blocks that have been integrated into extensive demonstrations to validate the critical design approaches. the ccpds-r pdr demonstration consisted of 130 ada tasks interconnected via 450 different task to task interfaces, executing in a network of 3 vax nodes. the extensive reuse of nas software building blocks and ada generics resulted in the translation of 120,000 ada source lines into over 2 million lines of executable machine language instructions. the nas software (about 20,000 ada source lines) was conceived in a trw independent research and development project in 1985, and has since been refined and evolved into a truly reusable state. although nas reuse is limited currently to digital equipment corporation vax vms networks, efforts are underway to provide heterogeneous nas capabilities.  the advantages of nas usage are twofold:  value added operational software through reuse of mission independent, performance tunable components which support open architectures, and  overall project productivity enhancement as a result of nas support for rapid prototyping, runtime instrumentation toolsuite, and encapsulation of the difficult capabilities required in any distributed real-time system into a standard set of building blocks with simple applications interfaces. this isolation of the "hard parts" into an easily used standard software chipset, results in a large net reduction in applications software complexity, less reliance on scarce real-time programming experts, and a substantial reduction in overall project risk.  this paper describes the message based design techniques which drove us to the development of nas, the capabilities and components inherent in the nas product, and the ccpds-r experience in using nas in a stringent real time command and control environment.  w. royce
preliminary experience with a configuration control system for modular programs  this paper describes some preliminary experience gathered during the implementation and early use of a program composition and version control system. this system has been designed and implemented as a part of the adele research project, a programming environment for the production of modular programs (estublier 83). this project has four main components: a) a program editor, interpreter and debugger; b) a parameterized code generator; c) a user interface; d) a program base, the subject of this paper. the current version of this environment has been developed on a multics system.  the program base, including the system composition and version control mechanisms, has been used for six months, notably for its own development and maintenance.  j. estublier s. ghoul s. krakowiak
increasing the use of apl  it appears that apl is used by only 5 to 10 percent of the programming population that might use it. after 15 years of commercial availability, many apl proponents find this a disappointing percentage. this paper reviews the main factors that inhibit the use of apl. it describes the factors, suggests means to overcome those factors, and gives examples of various apl systems that address the limiting factors.  john w. myrna
generating local addresses and communication sets for data-parallel programs  generating local addresses and communication sets is an important issue in distributed-memory implementations of data-parallel languages such as high performance fortran. we show that for an array a affinely aligned to a template that is distributed across p processors with a cyclic(k) distribution, and a computation involving the regular section a(l:h:s), the local memory access sequence for any processor is characterized by a finite state machine of at most k states. we present fast algorithms for computing the essential information about these state machines, and extend the framework to handle multidimensional arrays. we also show how to generate communication sets using the state machine approach. performance results show that this solution requires very little runtime overhead and acceptable preprocessing time.  siddhartha chatterjee john r. gilbert fred j. e. long robert schreiber shang- hua teng