waashk/acm huggingface dataset:
a survey of extensions to apl  a survey of proposed extensions to the apl language is made with emphasis placed on the motivations for various proposals, the differences between them and the consequences of their adoption. some issues of a more general nature concerning the purpose, process and direction of language extension are also discussed. an extensive bibliography is provided with annotations concerning the nature, development and influence of various authors' works. areas of extension encompassed by the survey include nested arrays, complex numbers, uniform application of functions, laminar extension, primitive functions, control structures, direct definition, operators, system functions and variables, name scope control and event trapping.  karl fritz ruehr
the structure and value of modularity in software design the concept of information hiding modularity is a cornerstone of modern software design thought, but its formulation remains casual and its emphasis on changeability is imperfectly related to the goal of creating added value in a given context. we need better explanatory and prescriptive models of the nature and value of information hiding. we evaluate the potential of a new theory---developed to account for the influence of modularity on the evolution of the computer industry---to inform software design. the theory uses _design structure matrices_ to model designs and _real options_ techniques to value them. to test the potential utility of the theory for software we apply it to parnas's kwic designs. we contribute an extension to design structure matrices, and we show that the options results are consistent with parnas's conclusions. our results suggest that such a theory does have potential to help inform software design.
principal values and branch cuts in complex apl  complex numbers are useful in science and engineering and, through analogy to the complex plane, in two-dimensional graphics, such as those for integrated- circuit layouts. the extension of apl to complex numbers requires many decisions. almost all have been discussed in detail in a recent series of papers. one topic requiring further discussion is the choice of branch cuts and principal values for the primitive apl functions that require them. conventional mathematical notation and the experience of other computer languages are of only moderate help. for example, one cannot find in the mathematics or computer-science literature a definitive value for the principal value of the arcsin of 3. the extension of apl to the complex domain presents a unique opportunity to define a set of choices that will best serve apl and other languages. this paper recommends locations of all branch cuts, directions of continuity of the branch cuts, and values at the branch points. it also recommends that comparison tolerance be used in the selection of principal values. the results apply to apl, other languages, applications packages, and vlsi hardware for complex calculations.  paul penfield
improving the precision of inca by preventing spurious cycles  the inequality necessary condition analyzer (inca) is a finite-state verification tool that has been able to check properties of some very large concurrent systems. inca checks a property of a concurrent system by generating a system of inequalities that must have integer solutions if the property can be violated. there may, however, be integer solutions to the inequalities that do not correspond to an execution violating the property. inca thus accepts the possibility of an inconclusive result in exchange for greater tractability. we describe here a method for eliminating one of the two main sources of these inconclusive results.  stephen f. siegel george s. avrunin
modelling stars using xml we suppose collections of xml data described by document type definitions (dtds). this data has been generated by applications and plays a role of oltp database(s). a star schema, a well-known technique used in data warehousing, can be applied. then dimension information is supposed to be contained in xml data. we will use the notions of subdtd and view, and formulate referential integrity constraints in xml environment. we use simple pattern matching capabilities of current xml query languages for xml view specification and tree embedding algorithms for these purposes. a dimension hierarchy is defined as a set of logically connected collections of xml data. facts may be also conceived as elements of an xml document. due to the structural complexity of xml data the approach requires subtler formal model than it is done with conventional dimension and fact tables described by classical star schemes. in consequence, our approach captures more from heterogeneity of source databases than it is done in classical relational approaches to data warehousing. jaroslav pokorny
taming architectural evolution in the world of software development _everything_ evolves. so, then, do software architectures. unlike source code, for which the use of a configuration management (cm) system is the predominant approach to capturing and managing evolution, approaches to capturing and managing architectural evolution span a wide range of disconnected alternatives. this paper contributes a novel architecture evolution environment, called mae, which brings together a number of these alternatives. the environment facilitates an incremental design process in which all changes to all architectural elements are integrally captured and related. key to the environment is a rich system model that combines architectural concepts with those from the field of cm. not only does this system model form the basis for mae, but in precisely capturing architectural evolution it also facilitates automated support for several innovative capabilities that rely on the integrated nature of the system model. this paper introduces three of those: the provision of design guidance at the architectural level, the use of specialized software connectors to ensure run- time reliability during component upgrades, and the creation of component- level patches to be applied to deployed system configurations. andre van der hoek marija mikic-rakic roshanak roshandel nenad medvidovic
acquiring experiences with executable process models  the primary thesis of this position paper is that it is mandatory to experiment with executable process models in order to obtain user feedback, to identify requirements on architectural components to support such models, and to investigate the impact of automation in the process itself. this paper briefly describes three generations of investigations with respect to the formalizing, modeling, and encoding of software life-cycle processes. providing for executable processes has been one of the most important goals of this work.  maria h. penedo
proof linking: modular verification of mobile programs in the presence of lazy, dynamic linking  although mobile code systems typically employ link-time code verifiers to protect host computers from potentially malicious code, implementation flaws in the verifiers may still leave the host system vulnerable to attack. compounding the inherent complexity of the verification algorithms themselves, the need to support lazy, dynamic linking in mobile code systems typically leads to architectures that exhibit strong interdependencies between the loader, the verifier, and the linker. to simplify verifier construction and provide improved assurances of verifier integrity, we propose a modular architecture based on the concept of proof linking. this architecture encapsulates the verification process and removes dependencies between the loader, the verifier, and the linker. we also formally model the process of proof linking and establish properties to which correct implementations must conform. as an example, we instantiate our architecture for the problem of java bytecode verification and assess the correctness of this instantiation. finally, we briefly discuss alternative mobile code verification architectures enabled by the proof-linking concept.  philip w. l. fong robert d. cameron
systems programming in concurrent prolog  concurrent prolog [28] combines the logic programming computation model with guarded-command indeterminacy and dataflow synchronization. it will form the basis of the kernel language [21] of the parallel inference machine [36], planned by japan's fifth generation computers project. this paper explores the feasibility of programming such a machine solely in concurrent prolog (in the absence of a lower-level programming language), by implementing in it a representative collection of systems programming problems.  ehud shapiro
in support of the ada 9x real-time facilities  the ada9x mapping has been criticised as being over ambitious and at odds with the "minimum change maximum benefit" ajpo dictum. consequently there is a need to cut back the scope of the proposed changes. this report considers the proposed changes which affect the programming of real-time single processor and multiprocessor systems.  we argue that protected records, select waiting, asynchronous transfer of control, nested asynchronous transfer of control are all essential core facilities, and if any of these are omitted the success of ada 9x in addressing the needs of the real-time community would be in serious jeopardy. if language simplification are deemed necessary, we would advocate the removal of user-defined timers, finalisation (but not abort exit handlers), and protected record functions.  a. burns a. j. wellings
formal specification and verification of the kernel functional unit of the osi session layer protocol and service using ccs this paper describes an application of formal methods to protocol specification, validation and verification. formal methods can be incorporated in protocol design and testing so that time and resources are saved on implementation, testing, and documentation. in this paper we show how formal methods can be used to write the control sequence, i.e. pseudo code, which can be formally tested using automated support. the formal specification serves as a blueprint for a correct implementation with desired properties.as a formal method we chose a process algebra called "plain" calculus of communicating systems (ccs). our specific objectives were to: 1) build a ccs model of the kernel functional unit of osi session layer service: 2) obtain a session protocol specification through stepwise refinement of the service specification; and 3) verify that the protocol specification satisfies the service specification. we achieved all of our objectives. verification and validation were accomplished by using the ccs's model checker, the edinburgh concurrency workbench (cwb). we chose plain ccs because of itssuccinct, abstract, and modular specifications, strong mathematical foundation which allows for formal reasoning and proofs, and existence of the automated support tool which supports temporal logic. the motivation for this work is: 1) testing the limits of ccs's succinct notation; 2) combining ccs and temporal logic; and 3) using a model-checker on a real- life example. milica barjaktarovic shiu-kai chin kamal jabbour
automatic input of flow chart in document image  the technology of document image processing has the possibility of automatic document input. by utilizing it, the flow chart in document image as the alternate expression of fortran source statements is automatically input into the computer. the paper reports the algorithm and the experimental results of field segmentation and classification in document image, the recognition of flow chart including control lines and blocks, and hand-written alpha- numerical characters in the blocks and the explanatory fields, the conversion of flow chart into program functions and the generation of fortran source statements. it showed the possibility that program functions such as initialization, input/output format and branch address were determined by the analysis of flow chart and explanatory description under the writing rule of it and also the restriction that the flow chart should have the good quality in order to recognize the flow and characters and be subject to the writing rule.  s. ito
a continuum of disk scheduling algorithms  a continuum of disk scheduling algorithms, v(r), having endpoints v(0) = sstf and v(1) = scan, is defined. v(r) maintains a current scan direction (in or out) and services next the request with the smallest effective distance. the effective distance of a request that lies in the current direction is its physical distance (in cylinders) from the read/write head. the effective distance of a request in the opposite direction is its physical distance plus r x (total number of cylinders on the disk). by use of simulation methods, it is shown that this definitional continuum also provides a continuum in performance, both with respect to the mean and with respect to the standard deviation of request waiting time. for objective functions that are linear combinations of the two measures, μw \\+ kow, intermediate points of the continuum are seen to provide performance uniformly superior to both sstf and scan. a method of implementing v(r) and the results of its experimental use in a real system are presented.  robert geist stephen daniel
context-sensitive interprocedural points-to analysis in the presence of function pointers  this paper reports on the design, implementation, and empirical results of a new method for dealing with the aliasing problem in c. the method is based on approximating the points-to relationships between accessible stack locations, and can be used to generate alias pairs, or used directly for other analyses and transformations.  our method provides context-sensitive interprocedural information based on analysis over invocation graphs that capture all calling contexts including recursive and mutually-recursive calling contexts. furthermore, the method allows the smooth integration for handling general function pointers in c.  we illustrate the effectiveness of the method with empirical results from an implementation in the mccat optimizing/parallelizing c compiler.  maryam emami rakesh ghiya laurie j. hendren
reuse of compiler analysis in a programming environment  productivity in the development of software can be increased by reusing code and design analysis. following this approach we have developed an incremental optimizing compiler that reuses target code and compiler analysis. in order to be practical, it shares a database of information with other tools in a programming environment. the analysis performed by a compiler is reused to greatly reduce the recompilation time during program development and to incrementally produce target code that is optimized across a larger unit than the unit of recompilation. the resulting code is as optimized as that produced in a batch environment, while saving up to 96% of the time for recompilation. the database used in the incremental optimizing compiler is also useful for other tools in a programming environment and is an approach to solving the problems of debugging optimized code.  m. p. blivens m. l. soffa
experimental evaluation of a generic abstract interpretation algorithm for prolog  abstract interpretation of prolog programs has attracted many researchers in recent years, partly because of the potential for optimization in prolog compilers and partly because of the declarative nature of logic programming languages that make them more amenable to optimization than procedural languages. most of the work, however, has remained at the theoretical level, focusing on the developments of frameworks and the definition of abstract domains.  this paper reports our effort to verify experimentally the practical value of this area of research. it describes the design and implementation of the generic abstract interpretation algorithm gaia that we originally proposed in le charlier et al. [1991], its instantiation to a sophisticated abstract domain (derived from bruynooghe and janssens [1988]) containing modes, types, sharing, and aliasing, and its evaluation both in terms of performance and accuracy. the overall implementation (over 5000 lines of pascal) has been systematically analyzed on a variety of programs and compared with the complexity analysis of le charlie et al. [1991] and the specific analysis systems of hickey and mudambi [1989], taylor [1989; 1990], van roy and despain [1990], and warren et al. [1988].  baudouin le charlier pascal van hentenryck
jack: a toolkit for manipulating articulated figures  the problem of positioning and manipulating three dimensional articulated figures is often handled by ad hoc techniques which are cumbersome to use. in this paper, we describe a system which provides a consistent and flexible user interface to a complex representation for articulated figures in a 3d environment. jack is a toolkit of routines for displaying and manipulating complex geometric figures, and it provides a method of interactively manipulating arbitrary homogeneous transformations with a mouse. these transformations may specify the position and orientation of figures within a scene or the joint transformations within the figures themselves. jack combines this method of 3d input with a flexible and informative screen management facility to provide a user-friendly interface for manipulating three dimensional objects.  cary b. phillips norman i. badler
design of a new user interface for apl  much progress has been made in apl systems during the last 10 years, however, most implementations still use the standard del editor, systems commands and a character oriented, user- typed, command interface. even the apl systems available for new graphics based workstation systems, such as macintosh and sun, do not fully exploit the user interface standards for those systems. it is now time to consider establishing a new standard user interface for apl running on hardware systems which support bit mapped graphics displays and a pointing device. this paper presents such a design which is based in part on the macintosh user interface, but includes special features for handling the apl workspace environment.  john e. howland
a form-based approach to human engineering methodologies  experience in the development and maintenance of software leads to the design of methodologies for different phases of the software engineering process. such methodologies attempt to usefully support the programmer's thought process for re-creating only good, standard patterns of programming without limiting creativity. however methodologies, as they are generally used, are limited in their impact on software quality. in this paper we present an approach for human engineering methodologies based on forms. the advantages of using a form-based interface for a software engineering environment are discussed by focusing on the design of forms, on the impact of forms on the software engineering process, and on the improved tool support facilitated by the standardization achieved by forms.  h. c. kuo c. h. li j. ramanathan
calculating joint queue-length distributions in product-form queuing networks  a new computational algorithm called distribution analysis by chain (dac) is developed. this algorithm computes joint queue-length distributions for product-form queuing networks with single-server fixed rate, infinite server, and queue-dependent service centers. joint distributions are essential in problems such as the calculation of availability measures using queuing network models. the algorithm is efficient since the cost to evaluate joint queue-length probabilities is of the same order as the number of these probabilities. this contrasts with the cost of evaluating these probabilities using previous algorithms. the dac algorithm also computes mean queue lengths and throughputs more efficiently than the recently proposed recal and mvac algorithms. furthermore, the algorithm is numerically stable and its recursion is surprisingly simple.  edmundo de souza e silva s. s. lavenberg
semicolon-bracket notation: a hidden resource in apl  the semicolon- bracket (sb) notation for indexing an array in apl has often been regarded unfavorably because of its anomalous character relative to other apl functions: the function symbol is a pair of brackets rather than a single character; the bracket pair is bound to the associated array at a higher precedence than any other function; and the requisite number of semicolons must appear literally within the brackets, so that the construct within the brackets when one or more semicolons are present is not an apl object, and therefore cannot be substituted for by another apl expression without semicolons. nevertheless, this notation provides a simple way to index arrays of any rank, and has proven to be very convenient in practice.  in this paper, it will be shown that the sb notation can (a) easily be extended to defined functions, and that it can also be used (b) to allow a multiplicity of names to be used unambiguously to the left of assignment, (c) to allow multiple statements on a line in a manner similar to that provided by the diamond separator in some apl systems, and (d) to extend and generalize the use of bracketed expressions as an axis operator.  a. d. falkoff
a linux kernel module implementation of restricted ada tasking an ada tasking kernel is implemented as a layer beneath the linux operating system on a pc- compatible machine. this implementation is derived from yodaiken's real-time linux kernel, with new scheduling and synchronization primitives introduced specifically to support the gnat ada runtime system. primitive operations for real-time ada tasks are directly implemented on top of the underlying hardware in the form of a loadable linux kernel module. this design not only reduces execution overhead and improves control over execution timing for tasks, but also opens the door for a simple restricted-tasking runtime system that could be certified for safety-critical applications. hongfeng shen theodore p. baker
a programming language framework for designing user interfaces  programming language researchers increasingly recognize that a high proportion of application development costs involve the interface with users of the application, including various dialogues, input formats, error checking, help and explanation messages, and the like. they also increasingly recognize that maintenance costs tend to overshadow development costs. these two factors even multiply their adverse effects: as the user needs evolve, it is the interface with a system which generally requires the most maintenance. the user relationship is even said to account for about 60 percent of the maintenance problem [lientz and swanson 81].  surprisingly, few programming language constructs are designed to address the area of user interface design. on the contrary, traditional programming language constructs are strongly oriented towards improving programmers' effectiveness in developing the algorithmic and data manipulation aspects of an application. a programmer is basically left to reinvent each time the required procedures to deal with user commands and inputs.  michel pilote