waashk/acm huggingface dataset:
vipers: a data flow visual programming environment based on the tcl language  this paper presents vipers, a new, general purpose, visual programming environment, based on an augmented data-flow model. the novel design peculiarity of vipers is the use of a fully programmable interpretive command language (tcl) to define the flow graph operators, as well as to control the behaviour and the appearance of the whole programming environment. we show how such a choice, with its resulting synergies, can lead to a multifeatured, flexible and convenient programming environment, where the application developer's tasks are remarkably simplified.  massimo bernini mauro mosconi
understandability of the software engineering method as an important factor for selecting a case tool  the article highlights the understandability of a software engineering methodology as an important criterion for selecting a case tool. this aspect is treated through the comparison of learning properties for two very well known methodology on which the case tools are usually based on. the first one is sa-sd and the second one is jsd. in the purpose to compare both methodology a group of young engineers has been tested. each of them wrote a seminar theme, answered a questionnaire and explained his observations. at the end of the paper, a general conclusion is presented.  i. rozman j. györkös k. rizmañ
coven: brewing better collaboration through software configuration management  our work focuses on building tools to support collaborative software development. we are building a new programming environment with integrated software configuration management which provides a variety of features to help programming teams coordinate their work.  in this paper, we detail a hierachy-based software configuration management system called _coven_, which acts as a collaborative medium for allowing teams of programmers to cooperate. by providing a family of inter-related mechanisms, our system provides powerful support for cooperation and coordination in a manner which matches the structure of development teams.  mark c. chu-carroll sara sprenkle
multiple downcasting techniques in this paper, we describe and compare techniques that implement multiple downcasting in strongly-typed languages. we conclude that multimethods stand out as the single best technique. in the first section, we describe seven commonly used techniques. in the second section, we compare these seven techniques using ten criteria. and, in the third section, we comment on some additional techniques.multiple downcasting occurs so often that developers use a variety of terms to describe it, and a variety of language constructs and patterns to implement it. "feed the animals," "driver-vehicle," and "parallel hierarchies" are well-known examples that require multiple downcasting. "multiple type dispatch" and "covariant subclassing" identify different facets of multiple downcasting. "dynamic type casting," "typecase statements," and the "visitor pattern" are frequently used to implement multiple downcasting. we believe that multiple downcasting is not a mistake or the result of poor program design, rather multiple downcasting is a specific technique that implements a specific kind of application semantics.in the animal hierarchy shown in figure 1, cows eat grass, wolves eat meat, and in the superclass, animals eat food. the generalization that animals eat food is imprecise: it ignores the facts that cows only eat grass and wolves only eat meat. so, how should developers write a function to safely "feed the animals" without getting the types mixed up? in program 1, we show how a developer might like to "feed the animals" in c++. the feed_unsafely function may fail, while the feed_safely function works properly for all combinations of foods and animals. the animal hierarchy will not compile in c++, because the eat method is covariant.in this paper, we elaborate ideas and examples from a middle-out concept of hierarchy. we adapted the "feed the animals" example from are cows animals? by shang. puppydog p. o. p. l. b. s. raccoon
contextbox (extended abstract) (poster session): a visual builder for context beans  we present an assembly-design environment that supports the javabeans extensible runtime containment and services protocol. the environment provides: a vehicle for demonstrating the java component model; a third-party client for testing beancontext and beancontextchild components; and a prototype illustrating how a visual builder might unify visual and context nesting during component assembly.  david h. lorenz predrag petkovic
the operating system kernel as a secure programmable machine to provide modularity and performance, operating system kernels should have only minimal embedded functionality. today's operating systems are large, inefficient and, most importantly, inflexible. in our view, most operating system performance and flexibility problems can be eliminated simply by pushing the operating system interface lower. our goal is to put abstractions traditionally implemented by the kernel out into user-space, where user-level libraries and servers abstract the exposed hardware resources. to achieve this goal, we have defined a new operating system structure, _exokernel,_ that safely exports the resources defined by the underlying hardware. to enable applications to benefit from full hardware functionality and performance, they are allowed to download additions to the supervisor-mode execution environment. to guarantee that these extensions are safe, techniques such as code inspection, inlined cross-domain procedure calls, and secure languages are used. to test and evaluate exokernels and their customization techniques a prototype exokernel, _aegis,_ is being developed. dawson r. engler m. frans kaashoek james w. o'toole
good news, bad news: experience building software development environment using the object-oriented paradigm  this paper presents our experience building an extendible software development environment using the object- oriented paradigm. we have found that object instances provide a natural way to model program constructs, and to capture complex relationships between different aspects of a software system. the object-oriented paradigm can be efficiently implemented on standard hardware and software, and provides some degree of extendibility without requiring major modifications to the existing implementation.  unfortunately, we have also found that some natural extensions that we would like to make to the environment are not easily incorporated. we argue that the lack of extendibility is due to the object-oriented paradigm's lack of support for providing modifications and extensions to the object-oriented paradigm itself.  w. h. harrison p. f. sweeney j. j. shilling
prism: a reverse engineering toolset this paper presents a process for the reengineering of computer-based control systems, and describes tools that automate portions of the process. the intermediate representation (ir) for capturing features of computer-based systems during reverse engineering is presented. a novel feature of the ir is that it incorporates the control system software architecture, a view that enables information to be captured at five levels of granularity: the program level, the task level, the package level, the subprogram level, and the statement level. a reverse engineering toolset that constructs the ir from ada programs, displays the ir, and computes metrics for concurrency, communication and object-orientedness is also presented. lonnie r. welch
software process enactment in oikos  despite much research work in progress to model the different facets of software process enactment from different approaches, there are no models yet generally recognized as adequate, and there is need for more experimentation. we describe the oikos environment and its coordination language esp: they provide an infrastructure in which experiments may be performed and evaluated.  oikos predefines a number of services offering basic facilities, like access to data bases, workspaces, user interfaces etc.. services are customizable, in a declarative way that matches naturally the way esp defines and controls the software process. esp allows to define services, to structure them in a dynamic hierarchy, and to coordinate them according to the blackboard paradigm. the concepts of environment and of software process and their interplay are naturally characterized in oikos, in terms of sets of services and of the hierarchy.  in the paper, an example taken from a real project (the specification of a small language and the implementation of its compiler) shows how oikos and esp are effective for software process enactment.  as it is, esp embeds prolog as its sequential component, and combines it smoothly to the blackboard approach to deal with concurrency and distribution. anyway, most of the concepts used to model and enact software processes are largely independent of logic programming.  v. ambriola p. ciancarini c. montangero
experience with flamingo: a distributed, object-oriented user interface system  the flamingo window management system is based on a remote method invocation mechanism that provides separate processes running in a heterogeneous, distributed computing environment with complete access to flamingo's objects and methods. this object-oriented interface has made flamingo a kernel window manager into which device drivers, graphics libraries, window managers and user interfaces can be dynamically loaded. this paper discusses the strengths and weaknesses of flamingo's system architecture, and introduces a new architecture which will provide a network-wide object space with object protection, migration, and garbage collection.  david b. anderson
technical correspondence  the column, "benchmarks for lan performance evaluation," by larry press (aug. 1988, pp. 1014-1017) presented a technique for quickly benchmarking the performance of lans in an office environment. our interest was peaked since office automation is growing in importance. as a result, an empirical analysis of the press benchmark programs was conducted. the results indicated that these benchmarking programs were appropriate for the benchmarking of lans in an office environment.  diane crawford
a practical parallel garbage collection algorithm and its implementation  one of the major problems of list processing programs is that of garbage collection. this paper presents a new practical parallel garbage collection algorithm and its improvements, and proposes a special processor for parallel garbage collection.  for the parallel garbage collection system, an urgent requirement is to reduce the the garbage collector cycle time that is defined as the total execution time for the marking and reclaiming phase. the effect of improvements discussed here reduces the garbage collector cycle time to one half of that for the original algorithm.  the performance of the processor tailored for parallel garbage collection is six times faster than that of an ordinary processor, while it requires a little bit larger amount of hardware than a typical channel controller. this processor satisfies the effectiveness condition for parallelism, even if the list process node consumption rate is high, e.g. when a compiled program is executed.  yasushi hibino
software pipelining irregular loops on the tms320c6000 vliw dsp architecture  the tms320c6000 architecture is a leading family of digital signal processors (dsps). to achieve peak performance, this vliw architecture relies heavily on software pipelining. traditionally, software pipelining has been restricted to _regular_ (for) loops. more recently, software pipelining has been extended to _irregular_ (while) loops, but only on architectures that provide special- purpose hardware such as rotating (predicate and general-purpose) register files, specific instructions for filling/draining software pipelined loops, and possibly hardware support for speculative code motion. in contrast, the tms320c6000 family has a limited, static register file and no specialized hardware beyond the ability to predicate instructions using a few static registers. in this paper, we describe our experience extending a production compiler for the tms320c6000 family to software pipeline irregular loops. we discuss our technique for preprocessing irregular loops so that they can be handled by the existing software pipeliner. our approach is much simpler than previous approaches and works very well in the presence of the dsp applications and the target architecture which characterize our environment. with this optimization, we achieve impressive speedups on several key dsp and non-dsp algorithms.  elana granston eric stotzer joe zbiciak
apl object manager  in order to co-ordinate apl code written for the european commission, which has several different computers (mainframes, minis and micros) and thus several different apl's, a comprehensive set of programming standards was developed. the standards outline, amongst other topics, how workspaces, apl objects and files should be structured, especially with respect to documentation. to aid the programmer to follow the standards, a development environment was produced and is now being used to develop systems written in dyalog apl. the development environment guides the user through various programming tasks and organizes the documentation associated with each apl object. this paper discusses the concepts and facilities of the development environment with specific references to the standards.  b. bykerk
maintaining the evolution of software objects in an integrated enviornment  this paper discusses the organization of software objects in an integrated environment from the software configuration management view. we will emphasize organization by evolution, by membership and by composition. the paper introduces program base objects which are version controlled in order to maintain the evolution of software objects. different specializations of such objects make it possible to maintain source objects and to support organization of software objects by membership and by composition in a uniform way.  a. gustavsson
verification of the application of coding rules for ada to enhance portability of real-time applications  in order to improve the portability of code for real time applications written in ada, a set of general coding rules has been compiled. in a second step, ada code constructs offending these rules were identified. in order to support the verification of the application of coding rules a static analysis tool was developed, which tests ada source code for these constructs and which indicates the offending constructs. since a syntactical analysis is insufficient to perform all necessary tests, the tool uses the asis-interface to ada libraries in order to obtain the necessary semantic information. different source code was tested with the tool. obvious differences can be observed depending on the application of the source code and its portation.  p. obermayer j. schröer r. a. peek n. collienne a. klimek r. landwehr
towards a distributed object-oriented propagation model using ada95 representing interdependencies between the objects of an object-oriented software application requires design-time mechanisms for specifying object interrelationships, as well as software constructs for the runtime maintenance of these relationships. we present a portion of our software engineering research environment adam, (short for active design and analyses modeling), which incorporates a technique for design-time modeling of _propagations_ (our term for the relationships between interdependent objects). we examine the adam environment's support for the automated generation of ada95 software constructs that maintain object interdependency at runtime. we focus on our propagation model's use of ada95 tasking constructs and protected objects, with an emphasis on the source level mechanisms through which our model utilizes concurrency. donald m. needham steven a. demurjian thomas j. peters
capsules: a data abstraction facility for pascal  described is a data type abstraction facility that has been implemented as an extension to the university of minnesota pascal 6000 compiler. the facility provides an encapsulation that establishes a static scope of identifiers with controlled visibility. the facility was developed primarily for instructional purposes for use throughout an undergraduate computer science curriculum in which pascal is the major language for program implementation. the paper begins with a brief background in which earlier abstraction facilities influencing the development of the capsule are described. then a description of the capsule and capsule parameterization (generics) facilities is provided, followed by an outline of the implementation of the capsule in a pascal compiler. plans for a generic capsule library and some comments concerning the use of the system in undergraduate instruction at temple university are given in the last section.  alessio giacomucci frank l. friedman
simultaneous reference allocation in code generation for dual data memory bank asips  we address the problem of code generation for dsp systems on a chip. in such systems, the amount of silicon devoted of program rom is limited, so application software must be sufficiently dense. additionally, the software must be written so as to meet various high-performance constraints, which may include hard real-time constraints. unfortunately, current compiler technology is unable to generate high-quality code for dsps, whose architectures are highly irregular. thus, designers often resort to programming application software in assembly---a time-consuming task.in this paper, we focus on providing support for architectural feature of dsps that makes code generation difficult, namely multiple data memory banks. this feature increases memory bandwith by permitting multiple data memory accesses to occur in parallel when the referenced variables belong to different data memory banks and the registers involved conform to a strict set of conditions. we present an algorithm that attempst to maximize the benefit of this architectural feature. while previous approaches have decoupled the phases of register allocation and memory bank assignment, thereby compromising code quality, our algorithm performs these two phases simultaneously. experimental results demonstrate that our algorithm not only generates high-quality compiled code, but also improves the quality of completely-referenced code.  ashok sudarsanam sharad malik
on the power and limitations of strictness analysis  strictness analysis is an important technique for optimization of lazy functional languages. it is well known that all strictness analysis methods are incomplete, i.e., fail to report some strictness properties. in this paper, we provide a precise and formal characterization of the loss of information that leads to this incompletenss. specifically, we establish the following characterization theorem for mycroft's strictness analysis method and a generalization of this method, called ee- analysis, that reasons about exhaustive evaluation in nonflat domains: mycroft's method will deduce a strictness property for program p iff the property is independent of any constant appearing in any evaluation of p. to prove this, we specify a small set of equations, called e-axioms, that capture the information loss in mycroft's method and develop a new proof technique called e-rewriting. e-rewriting extends the standard notion of rewriting to permit the use of reductions using e-axioms interspersed with standard reduction steps. e-axioms are a syntactic characterization of information loss and e-rewriting provides and algorithm-independent proof technique for characterizing the power of analysis methods. it can be used to answer questions on completeness and incompleteness of mycroft's method on certain natural classes of programs. finally, the techniques developed in this paper provide a general principle for establishing similar results for other analysis methods such as those based on abstract interpretation. as a demonstration of the generality of our technique, we give a characterization theorem for another variation of mycroft's method called dd-analysis.  r. sekar i. v. ramakrishnan p. mishra
issues in the full scale use of formal methods for automated testing experience from a full scale effort to apply formal methods to automated testing in the open systems software arena is described. the formal method applied in this work is based upon the clemson automated testing system (cats) which includes a formal specification language, a set of guidelines describing how to use the method effectively, and tool support capable of translating formal specifications into executable tests. this method is currently being used to develop a full scale test suite for ieee's ada language binding to posix. following an overview of cats, an experience report consisting of results, lessons learned and future directions is presented. j. l. crowley j. f. leathrum k. a. liburdy
a framework for construction and evaluation of high-level specifications for program analysis techniques  abstract interpretation introduced the notion of formal specification of program analyses. denotational frameworks are convenient for reasoning about such specifications. however, implementation considerations make denotational specifications complex and hard to develop. we present a framework that facilitates the construction and understanding of denotational specifications for program analysis techniques. the framework is exemplified by specifications for program analysis techniques from the literature and from our own research. this approach allows program analysis techniques to be incorporated into automatically generated program synthesizers by including their specifications with the language definition.  g. a. venkatesh
a comparison of data flow path selection criteria  a number of path selection testing criteria have been proposed throughout the years. unfortunately, little work has been done on comparing these criteria. to determine what would be an effective path selection criterion for revealing errors in programs, we have undertaken an evaluation of these criteria. this paper reports on the results of our evaluation for those path selection criteria based on data flow relationships. we show how these criteria relate to each other, thereby demonstrating some of their strengths and weaknesses.  lori a. clarke andy podgurski debra j. richardson steven j. zeil