waashk/acm huggingface dataset:
an ada reuse support system for windows 95/nt this paper describes a software resource that is being developed as part of the graduation requirement for the master in software engineering degree at the university of scranton. this project evolved from a series of experiments that were performed in undergraduate and graduate courses at the university. a basic editor was developed as part of an undergraduate course in rapid prototyping. several students used that project as the basis for undergraduate senior projects. all undergraduates are required to complete a project as a degree requirement. this basic editor was handed over to a graduate course in software generation and maintenance and used as the starting point for the construction of various software project management features. the system was constructed to support ada source code development. however, the system could be readily modified to support source code management in other languages, notably c++. this paper describes the construction of resources that encourage the use of reusable software. subsequent sections describe the overall framework of the system and selected details that carry out features that make reuse attractive. the system is called **reuse** (the **re**use **u**niversity of **s**cranton **e**nvironment).reuse is an ada programming environment which facilitates and promotes code reuse by individual developers or teams of developers. it provides centralized storage of project files, a package browser, automatic function and procedure call creation, a compiler interface, interactive error processing, multiple simultaneous editors, standard windows tools (menus, toolbars, etc.), and other features to help the developer write and reuse ada code efficiently.reuse was developed in microsoft visual basic 4.0 (32-bit) for the windows 95 / nt operating systems. david battaglia austin burke john beidler
moving decision points outward from applications and utilities and into command level  the user command interface of an operating system has come to be regarded as the outermost level in a layered hierarchy. in keeping with this view one should attempt to move decision points outward from the lower operating layers, so that all required actions can be defined at command level. that will allow the description of those actions in a form that matches the form of other commands normally entered from the keyboard, so that only a minimal amount of programming skill will be required. an example of this strategy is developed for implementation under generic msdos (microsoft) and rt11 (digital equipment corporation).  maarten van swaay
metric-driven reengineering for static concurrency analysis  an approach to statically analyzing a concurrent program not suited for analysis is described. the program is reengineered to reduce the complexity of concurrency-related activities, thereby reducing the size of the concurrency state space. the key to the reengineering process is a metric set that characterizes program task interaction complexity and provides guidance for restructuring. an initial version of a metric set is proposed and applied to two examples to demonstrate the utility of the reengineering-for-analysis process. the reengineering has potential benefits apart from supporting analyzability, following the dictum that if it is hard to analyze, it is hard to understand and maintain.  david l. levine richard n. taylor
a problem-oriented analysis of basic uml static requirements modeling concepts  the unified modeling language (uml) is a standard modeling language in which some of the best object-oriented (oo) modeling experiences are embedded. in this paper we illustrate the role formal specification techniques can play in developing a precise semantics for the uml. we present a precise characterization of requirements-level (problem- oriented) class diagrams and outline how the characterization can be used to semantically analyze requirements class diagrams.  robert france
adapting ada distribution and fault tolerance  during the third international real time ada workshop held at nemacolin woodlands, pennsylvania, in june 1989, the present authors formed a study group to review the changes in the ada standard which would make the language more suitable for programming distributed systems. it was accepted that one of the important advantages of distributing embedded systems was the potential for recovery from partial failure of hardware, and that the techniques of programming recovery from such failure were not well supported by the current form of ada. the working group made specific proposals, which have since been refined at a further meeting and discussions by electronic mail. the present paper reviews the causes of difficulty, and then outlines the new proposals, explaining their rationale in relation to the identified requirements.  a. b. gargaro s. j. goldsack r. k. powers r. a. volz a. j. wellings
the architecture and performance of security protocols in the ensemble group communication system: using diamonds to guard the castle ensemble is a group communication system built at cornell and the hebrew universities. it allows processes to create _process groups_ within which scalable reliable fifo- ordered multicast and point-to-point communication are supported. the system also supports other communication properties, such as causal and total multicast ordering, flow control, and the like. this article describes the security protocols and infrastructure of ensemble. applications using ensemble with the extensions described here benefit from strong security properties. under the assumption that trusted processes will not be corrupted, all communication is secured from tampering by outsiders. our work extends previous work performed in the horus system (ensemble's predecessor) by adding support for multiple partitions, efficient rekeying, and application-defined security policies. unlike horus, which used its own security infrastructure with nonstandard key distribution and timing services, ensemble's security mechanism is based on off-the shelf authentication systems, such as pgp and kerberos. we extend previous results on group rekeying, with a novel protocol that makes use of diamondlike data structures. our diamond protocol allows the removal of untrusted members within milliseconds. in this work we are considering configurations of hundreds of members, and further assume that member trust policies are symmetric and transitive. these assumptions dictate some of our design decisions.
a general framework for formalizing uml with formal languages  _informal and graphical modeling techniques enable developers to construct abstract representations of systems. object-oriented modeling techniques further facilitate the development process. the_ unified modeling language _(uml), an object-oriented modeling approach, could be broad enough in scope to represent a variety of domains and gain widespread use. currently, uml comprises several different notations with no formal semantics attached to the individual diagrams. therefore, it is not possible to apply rigorous automated analysis or to execute a uml model in order to test its behavior, short of writing code and performing exhaustive testing. we introduce a general framework for formalizing a subset of uml diagrams in terms of different formal languages based on a homomorphic mapping between metamodels describing uml and the formal language. this framework enables the construction of a consistent set of rules for transforming uml models into specifications in the formal language. the resulting specifications derived from uml diagrams enable either execution through simulation or analysis through model checking, using existing tools. this paper describes the use of this framework for formalizing uml to model and analyze embedded systems. a prototype system for generating the formal specifications and results from an industrial case study are also described._  william e. mcumber betty h. c. cheng
machine-oriented languages in the apl environment  many apl systems, especially mainframe systems, have made it inconvenient or impossible for users to write subroutines in machine-oriented languages (e.g., fortran, c, or assembler). this deficiency has had a serious impact on apl, preventing it from competing with conventional compiled languages for speed and access to hardware capabilities. the trend in modern apl systems, particularly microcomputer systems, is to provide more convenient and flexible access to machine-oriented programs. this paper describes the machine-level interfaces provided by several apl systems, lists desirable features of such interfaces, gives examples of what machine-oriented programs can be used for, and takes a speculative look at the future.  jim weigang
self-organizing distributed operating system: implementation and problem using ada  this paper introduces a new concept: "self- organization" in distributed operating system. up to now, the communication facilities in distributed systems were almost based on the assumption: the human intervention. software systems for c i m (computer integrated manufacturing), however, should be highly intelligent, i.e., highly dependable and dynamically evolving (and/or gracefully degrading) systems.  the most serious drawback of ada faced with developing distributed software is the rendezvous mechanism of tasking which provides one-to-one communication facility. one-to-many communication mechanism should be provided. furthermore, communication facility in distributed system should be self-organized so as to fit the requirements of the problem such as in neural nets.  the main idea of this paper is to "self-organize" the communication facilities according to (physical and/or virtual) structural change of communication networks. the mechanism and implementation strategy for the self-organizing distributed operating system are described. a prototype system-1 is being constructed on ten suns network using verdix ada compiler. the advantages of using ada over other languages in constructing distributed operating system are the dynamic data structure and package supported by separate compilation facility. problems facing with this project also will be discussed.  shohei fujita
reducing the effects of infeasible paths in branch testing  branch testing, which is one of the most widely used methods for program testing, see white [1] for example, involves executing a selected set of program paths in an attempt to exercise all program branches. criteria for selecting such paths have, to date, received scant attention in the literature and it is the issue of developing a suitable path selection strategy to which this paper is addressed. specifically, a selection strategy, which aims at reducing the number of infeasible paths generated during the branch testing exercise is proposed. the strategy is founded on an assertion concerning the likely feasibility of program paths. statistical evidence in support of the assertion is provided, a method implementing the strategy is described, and the results obtained from applying the method to a set of program units are reported and analysed.  d. yates n. malevris
a program complexity metric based on data flow information in control graphs  this paper presents a new approach to measuring program complexity with the use of data flow information in programs. a complexity metric, called du, is defined for the control graph of a structured program. this new metric is different from other control-graph based metrics in that it is based on "representative" data flow information in a control graph. an algorithm for computing the value of du(g) for a control graph g is given. the lower and upper bounds of du(g) are provided. the du metric is shown to have several advantages over other control-graph based complexity metrics.  kuo-chung tai
operators for recursion  recursion is frequently used in functional programming languages. in lisp, it is the primary means of traversing data structures, and, along with cond, is instrumental in controlling program flow. in apl2, the generalization of arrays to include arrays of arrays encourages the use of recursion. this usage is enhanced by the generalization of, and extensions to, operators. in particular, the ability to define operators allows us to create operators which simplify the coding of recursive logic.  this paper studies the use of operators to provide program control for solutions to problems which involve recursion. for the most part, iteration on the elements of a list is used to replace recursive function calls.  the program control methods used in this paper are introduced in a companion paper, operators for program control (eusebi[3]). the reader is encouraged to read that paper first.  edward v. eusebi
liseb: a language for modeling living systems with apl2  the paper discusses the design and implementation of liseb, a class-based language built on top of apl2 to respond to challenges posed by modelling living systems from a medical point of view. liseb capitalises on several features of apl and on some lessons learned from its history. living systems are modelled as open systems: environments in which concurrent mobile autonomous agents interact. modelling of these properties required extensions of traditional object- oriented paradigms and of their previous translations under apl: a) every object performs a sequence of actions dynamically modified to adapt to circumstances; b) a new policy of message management is introduced uniformly encompassing broadcast and directly addressed communication. an example of a simulation using liseb illustrates these concepts.  p. bottoni m. mariotto p. mussio
verification of real-time designs: combining scheduling theory with automatic formal verification  we present an automatic approach to verify designs of real-time distributed systems for complex timing requirements. we focus our analysis on designs which adhere to the hypothesis of analytical theory for fixed-priority scheduling. unlike previous formal approaches, we draw from that theory and build small formal models (based on timed automata) to be analyzed by means of model checking tools. we are thus integrating scheduling analysis into the framework of automatic formal verification.  victor a. braberman miguel felder
corba vs. ada 95 dsa: a programmer's view recent evolutions in computer networks have made it possible to consider distributed platforms as possible architectures for numerous applications. the classes of distributed applications are numerous and go from time consuming application (performance quest) to geographically distributed applications through safety and critical softwares. as beforehand, hardware evolutions have been fast paced and much earlier than software techniques to build applications on these distributed targets. in this paper, we shall investigate and compare three different approaches: the language approach of ada 95 for distributed systems vs. two distributed platforms. and for this evaluation, we shall take the developer's view, that is to go beyond the technical response but to take into account the developer of the distributed application. yvon kermarrec
emeralds: a small-memory real-time microkernel emeralds (extensible microkernel for embedded, real-time, distributed systems) is a real-time microkernel designed for small-memory embedded applications. these applications must run on slow (15-25mhz) processors with just 32-128 kbytes of memory, either to keep production costs down in mass-produced systems or to keep weight and power consumption low. to be feasible for such applications, the os must not only be small in size (less than 20 kbytes), but also have low-overhead kernel services. unlike commercial embedded oss which rely on carefully-crafted code to achieve efficiency, emeralds takes the approach of re-designing the basic os services of task scheduling, synchronization, communication, and system call mechanism by using characteristics found in small-memory embedded systems, such as small code size and _a priori_ knowledge of task execution and communication patterns. with these new schemes, the overheads of various os services are reduced 20-40% without compromising any os functionality. khawar m. zuberi padmanabhan pillai kang g. shin
a parallel prolog: the construction of a data driven model  an argument is presented for the implementation of a prolog-like language using data driven execution, as a step towards the solution of the problems associated with multiprocessor machine architectures. to facilitate this, a number of changes and extensions to the execution control mechanism of prolog have been implemented. among the notable features of the system are the use of conditional and (cand) and conditional or (cor) constructs to allow the programmer sequential control in the context of a parallel execution system, and mechanisms supporting dataflow execution within groups of parallel literals. a tentative solution proposed for the evaluation of negative literals is also being investigated.  michael j. wise
functional array fusion this paper introduces a new approach to optimizing array algorithms in functional languages. we are specifically aiming at an efficient implementation of irregular array algorithms that are hard to implement in conventional array languages such as fortran. we optimize the storage layout of arrays containing complex data structures and reduce the running time of functions operating on these arrays by means of equational program transformations. in particular, this paper discusses a novel form of combinator loop fusion, which by removing intermediate structures optimizes the use of the memory hierarchy. we identify a combinator named loop p that provides a general scheme for iterating over an array and that in conjunction with an array constructor replicate p is sufficient to express a wide range of array algorithms. on this basis, we define equational transformation rules that combine traversals of loop p and replicate p as well as sequences of applications of loop p into a single loop p traversal. our approach naturally generalizes to a parallel implementation and includes facilities for optimizing load balancing and communication. a prototype implementation based on the rewrite rule pragma of the glasgow haskell compiler is significantly faster than standard haskell arrays and approaches the speed of hand coded c for simple examples. manuel m. t. chakravarty gabriele keller
microcomputers as remote nodes of a distributed system  a time-sharing system may be extended into a general-purpose distributed computing facility through the use of remote microcomputer systems. in such an extension the microcomputer system is not merely a remote terminal but a complete computer system. it becomes part of an integrated network of computers, each with significant local computational power with access to host system data resources. the implementation described emphasizes ease-of-use by minimizing any differences between local and remote data use.  michael a. pechura
the role of distributed, real-time ada & c++ on the airborne surveillance testbed (ast) program the airborne surveillance testbed (ast) program, managed by smdc for bmdo, is a technology demonstration program that supports development, test, and evaluation of defensive systems to counter intercontinental and theater ballistic missiles (icbms and tbms) and their warheads. the heart of the ast program is a boeing 767 aircraft equipped with a raytheon-built, large-aperture, multiband, high data rate infrared sensor and a wide variety of processing equipment designed to detect, track, and discriminate ballistic missiles at long ranges. a raytheon interceptor seeker (part of a navy risk reduction effort) has recently been integrated onto the aircraft; a staring medium wave infrared (mwir) camera is currently being added as well. onboard processing capabilities include a concurrent turbohawk (multi-cpu powerpc flight computer) along with a variety of custom and off- the-shelf signal processing equipment, sgi workstations, dec alphas, and pcs, largely programmed in ada and c++. these systems are linked via scramnet, ethernet, 1553b, rs422 and rs232, and communicate externally via various radio systems. since the start of the program in 1984, ast has been making use of ada83, ada95, and c++ for both simulations and embedded flight software. during that time, we have gathered a lot of experience in the use of ada for real-time distributed systems, especially concerning: the pitfalls of task scheduling algorithms and priorities the benefits of the (careful) use of generics the importance of some changes between ada83 and ada95 interfacing ada software to hardware (and standardized interrupt handling) the importance of proper use of exception handling to ensure fault tolerance henry a. lortz timothy a. tibbetts
an overview of dod-std-1838a (proposed) the common apse interface set: revision  a five-year effort under the ada joint program office has developed a proposed standard for a host system interface as seen by tools running in an ada programming support environment (apse). standardization of this interface as dod-std-1838a will have a number of desirable effects for the department of defense, including tool portability, tool integration, data transportability, encouragement of a market in portable tools, and better programmer productivity.  as the capability of tools to communicate with each other is a central requirement in apses, the common apse interface set (cais) has paid particular attention to facilitate such communication in a host-independent fashion. cais incorporates a well- integrated set of concepts tuned to the needs of writers and users of integrated tool sets.  this paper covers several of these concepts:  • the entity management system used in place of a traditional filing system,  • object typing with inheritance,  • process control including atomic transactions,  • access control and security,  • input/output methods,  • support for distributed resource control, and  • facilities for inter-system data transport.  robert munck patricia oberndorf erhard ploedereder richard thall
dynamic i/o power management for hard real-time systems  _power consumption is an important design parameter for embedded and portable systems. software-controlled (or dynamic) power management (dpm) has recently emerged as an attractive alternative to inflexible hardware solutions. dpm for hard real-time systems has received relatively little attention. in particular, energy-driven i/o device scheduling for real-time systems has not been considered before. we present the first online dpm algorithm, which we call_ l_ow_ e_nergy_ d_evice_ s_cheduler (ledes), for hard real-time systems. ledes takes as inputs a predetermined task schedule and a device-usage list for each task and it generates a sequence of sleep/working states for each device. it guarantees that real-time constraints are not violated and it also minimizes the energy consumed by the i/o devices used by the task set. ledes is energy-optimal under the constraint that the start times of the tasks are fixed. we present a case study to show that ledes can reduce energy consumption by almost 50%._  vishnu swaminathan krishnendu chakrabarty s. s. iyengar
modules for standard ml  the functional programming language ml has been undergoing a thorough redesign during the past year, and the module facility described here has been proposed as part of the revised language, now called standard ml. the design has three main goals: (1) to facilitate the structuring of large ml programs; (2) to support separate compilation and generic library units; and (3) to employ new ideas in the semantics of data types to extend the power of ml's polymorphic type system. it is based on concepts inherent in the structure of ml, primarily the notions of a declaration, its type signature, and the environment that it denotes.  david macqueen