waashk/acm huggingface dataset:
managing software processes in the environment melmac  in this paper we introduce an approach to software process modeling and execution based on the distinction between an application level (oriented towards a comprehensive representation of software process models) and an intermediate level representation of software process models (oriented towards uniform and executable description of software process models). the application level representation of software models identifies various entities of software process models. for describing different entities of software process models different views are used. the entities specified within all the views are uniformly represented on the intermediate level by funsoft nets. funsoft nets are high-level petri nets which are adapted to the requirements of software process management. a mechanism for coping with software process model modifications raised in software process execution is introduced. this mechanism is based on modification points. moreover, we discuss the architecture of the environment melmac which supports software process modeling as well as software process execution.  volker gruhn
software quality test accuracy test coverage  the software quality index, spql (software product quality level), is proposed. the index indicates the software quality based on program test results and consists of two subindices: the test accuracy index and the test coverage index. the test accuracy index can be measured by applying the capture- recapture method. pseudo defects called control defects are seeded prior to the test and their capture ratio is measured as the ratio of the number of detected defects to the estimated number of detectable defects (estimated by applying the software reliability growth model). two experimental results are presented and the spql is compared with both the ordinary capture-recapture method and the software reliability growth prediction based method. the result indicates that the spql is practical.  m. ohba
distributed data access in ac  we have modified the c language to support a programming model based on a shared address space with physically distributed memory. with this model users can write programs in which the nodes of a massively parallel processor can access remote memory without message passing. ac provides support for distributed arrays as well as pointers to distributed data. simple array references and pointer dereferencing are sufficient to generate low-overhead remote reads and writes. we have implemented these ideas in a compiler based on the gnu c compiler and targeted at cray research's t3d. initial performance measurements show that ac generates code for remote accesses which is considerably faster than that of the native compiler for structures up to about 16 words in size and virtually equivalent for larger transfers.  william w. carlson jesse m. draper
an integrated toolset for engineering software configurations  configuration management in toolkit oriented software development environments (sde), such as the unix system, is a long standing nuisance. mostly, one has to face the choice between poorly or not at all integrated, independent tools, or highly integrated, most specialized, and often language dependent environments. the first choice offers very limited support for a complex task that needs a broad informational basis. the second choice often takes away the programmers' most cherished tools, forces him to adopt some different work discipline, and thereby eventually restricts his creativity. the toolset described in this paper integrates a dedicated version control system and shape, a significantly enhanced make [feld79a] program, on the basis of a common object model. this object model comprises multiple versions of software objects as well as conventional file system objects. taking this approach made it possible to have a sufficiently integrated toolsystem for engineering software configurations while retaining the flexibility of the basic toolbox philosophy, permitting the use of 'off-the-shelf' tools, e.g. editors or compilers.  axel mahler andreas lampen
from recursion to iteration: what are the optimizations?  transforming recursion into iteration eliminates the use of stack frames during program execution. it has been studied extensively. this paper describes a powerful and systematic method, based on incrementalization, for transforming general recursion into iteration: identify an input increment, derive an incremental version under the input increment, and form an iterative computation using the incremental version. exploiting incrementalization yields iterative computation in a uniform way and also allows additional optimizations to be explored cleanly and applied systematically, in most cases yielding iterative programs that use constant additional space, reducing additional space usage asymptotically, and run much faster. we summarize major optimizations, complexity improvements, and performance measurements.  yanhong a. liu scott d. stoller
compiling into apl  in some programming situations apl code can become as obtuse as that of other languages. one possible way to deal with such instances is to create a high- order programming language (hopl) which provides an easy-to-code, easy-to- maintain structure and which may be compiled straight-forwardly into apl functions for execution.  since the hopl is designed for relatively narrow fields of use, it can be tailored directly to the problem which it solves. two of the areas where the hopl concept has proven useful are implementation of a simple, interactive graphics system and selection of data records from a database. we draw examples from these areas to discuss the concept and use of hopl's.  george r. mayforth
controlling propagation of operations using attributes on relations  controlling the propagation of operations through a collection of objects connected by various relationships has been a problem both for the object- oriented and the data base communities. operations such as copy, destroy, print, and save must propagate to some, but not all, of the objects in a collection. such operations can be implemented using ad hoc methods on objects, at the cost of extra work and loss of clarity. the use of propagation attributes on the relationships between objects permits a concise, intuitive specification of the manner in which operations should propagate from one object to another. these concepts have been implemented in the object-oriented language dsm and have been used to write applications.  james rumbaugh
mini-exec: a portable executive for 8-bit microcomputers  as microprocessor systems and single-chip microcomputers become more complex, so do the software systems developed for them. in many cases, software is being designed that incorporates multiple control functions running asynchronously on a single microprocessor. here, discussion focuses on the motivation for running such multiple functions under the control of a real- time multitasking executive. a successfully implemented executive whose design is portable and suitable for use on most 8-bit microprocessors is presented.  thomas l. wicklund
separating access control policy, enforcement, and functionality in extensible systems  extensible systems, such as java or the spin extensible operating system, allow for units of code, or extensions, to be added to a running system in almost arbitrary fashion. extensions closely interact through low-latency but type-safe interfaces to form a tightly integrated system. as extensions can come from arbitrary sources, not all of whom can be trusted to conform to an organization's security policy, such structuring raises the question of how security constraints are enforced in an extensible system. in this paper, we present an access control mechanism for extensible systems to address this problem. our access control mechanism decomposes access control into a policy- neutral enforcement manager and a security policy manager, and it is transparent to extensions in the absence of security violations. it structures the system into protection domains, enforces protection domains through access control checks, and performs auditing of system operations. the access control mechanism works by inspecting extensions for their types and operations to determine which abstractions require protection and by redirecting procedure or method invocations to inject access control operations into the system. we describe the design of this access control mechanism, present an implementation within the spin extensible operating systems, and provide a qualitative as well as quantitative evaluation of the mechanism.  robert grimm brian n. bershad
a session with tinker: interleaving program testing with program design  tinker is an experimental interactive programming system which integrates program testing with program design. new procedures are created by working out the steps of the procedure in concrete situations. tinker displays the results of each step as it is performed, and constructs a procedure for the general case from sample calculations. the user communicates with tinker mostly by selecting operations from menus on an interactive graphic display rather than by typing commands. this paper presents a demonstration of our current implementation of tinker.  henry lieberman carl hewitt
evaluation of java thread performance on two different multithreaded kernels modern programming languages and operating systems encourage the use of threads to exploit concurrency and simplify program structure. an integral and important part of the java language is its multithreading capability. despite the portability of java threads across almost all platforms, the performance of java threads varies according to the multithreading support of the underlying operating system and the way java virtual machine maps java threads to the native system threads. in this paper, a well-known compute-intensive benchmark, the ep benchmark, was used to examine various performance issues involved in the execution of threads on two different multithreaded platforms: windows nt and solaris. experiments were carried out to investigate thread creation and computation behavior under different system loads, and to explore execution features under certain extreme situations such as the concurrent execution of very large number of java threads. some of the experimental results obtained from threads were compared with a similar implementation using processes. these results show that the performance of java threads differs depending on the various mechanisms used to map java threads to native system threads, as well as on the scheduling policies for these native threads. thus, this paper provides important insights into the behavior and performance of java threads on these two platforms, and highlights the pitfalls that may be encountered when developing multithreaded java programs. yan gu b. s. lee wentong cai
role model designs and implementations with aspect-oriented programming  this paper describes research in applications of aspect-oriented programming (aop) as captured in the aspectj language. in particular, it compares object- oriented and aspect-oriented designs and implementations of role models.  sections 1, 2, and 3 provide background information on role models, object- oriented role model implementations, and aspect-oriented programming, respectively. new aspect-oriented designs for role models are explored in sections 4, 5, and 6.  the base reference for this exploration is the role object pattern. although useful for role models, this pattern introduces some problems at the implementation level, namely object schizophrenia, significant interface maintenance, and no support for role composition. our research has resulted in alternative aspect- oriented designs that alleviate some of these problems.  section 7 discusses how an agent framework that implements role models has been partially reengineered with aspects. the reengineering addressed concerns that are orthogonal or cross cut both the core and the role behavior. the aspect oriented redesign significantly reduced code tangling, overall method and module count, and total lines of code. these results and other conclusions are presented in section 8.  elizabeth a. kendall
java bytecode compression for low-end embedded systems  a program executing on a low-end embedded system, such as a smart-card, faces scarce memory resources and fixed execution time constraints. we demonstrate that factorization of common instruction sequences in java bytecode allows the memory footprint to be reduced, on average, to 85% of its original size, with a minimal execution time penalty. while preserving java compatibility, our solution requires only a few modifications which are straightforward to implement in any jvm used in a low-end embedded system.  lars ræder clausen ulrik pagh schultz charles consel gilles muller
a time-sensitive object model for real-time systems  process-oriented models for real-time systems focus on the timing constraints of processes, a focus that can adversely affect resulting designs. data dependencies between processes create scheduling interactions that limit the times at which processes may execute. processes are then designed to fit available windows in the overall system schedule. "fitting in" frequently involves fragmenting processes to fit scheduling windows and/or designing program and data structures for speed rather than for program comprehension. the result is often a system with very sensitive timing that is hard to understand and maintain. as an alternative to process-oriented design, we present time-sensitive objects: a data-oriented model for real-time systems. the time-sensitive object (tso) model structures systems as time-constrained data, rather than time constrained processing. object values are extended to object histories in which a sequence of time constrained values describe the evolution of the object over time. systems comprise a set of objects and their dependencies. the tso model describes the effects of object operations and the propagation of change among related objects. periodic objects, a class of objects within the tso model, are described in detail in this article and compared with traditional periodic processes. advantages of time-sensitive objects are identified, including greater scheduling independence when processes have data dependencies, more opportunity for concurrency, and greater inherent capability for detection of and tolerance to timing errors.  h. rebecca callison
development of a parallel algorithmic language (abstract only)  rolla* \\- a new style of programming is needed to meet the increased demands of computational speed. a software system based on dataflow and designed to use parallelism in future architectures is envisioned. the language model is designed so that any algorithm can be easily communicated to both man and machine. the basic entity of the model is that of units which are interconnected by a series of data paths like pipes. a unit is any process, file or device capable of consuming or supplying data. consuming and supplying pairs are categorized by the type of flow of data between units. a notation has been developed to express the dataflow graphs which exposes the parallel nature of the model. ports, index numbers and process names allow an unambiguous representation of the graphs and support nesting to any level. further research is being done in the area of unit description and dataflow control.  roger eggen john r. metzner
integrated concurrency analysis in a software development enviornment  the inherent difficulties of analyzing concurrent software make reliance on a single technique or a single monolithic tool unsatisfactory. a better approach is to apply multiple analysis and verification techniques by coordinating the activities of a variety of small tool components. we describe how this approach has shaped the design of a set of tool components to support concurrency analysis in the arcadia-1 software development environment. implementation and experience with key components is described.  m. young r. taylor k. forester d. brodbeck
a solution to a problem with morel and renvoise's "global optimization by suppression of partial redundancies"  morel and renvoise have previously described a method for global optimization and code motion by suppression of partial redundancies [l]. morel and renvoise use data flow analysis to determine expression computations that should be inserted at the end of certain basic blocks and to determine redundant computations that can be eliminated. the execution of these techniques results in the movement of loop invariant expressions out of the loop. in addition to [l] morel and renvoise's techniques can also be applied to subexpressions of larger expressions. then, however, in certain special cases these optimization techniques move expressions to places where some of its subexpressions are neither available nor moved together with the expression. in this paper we present a modification of morel and renvoise's algorithm that avoids the above described situations.  karl-heinz drechsler manfred p. stadel
a debate on language and tool support for design patterns  design patterns have earned a place in the developer's arsenal of tools and techniques for software development. they have proved so useful, in fact, that some have called for their promotion to programming language features. in turn this has rekindled the age-old debate over the mechanism that belong in programming languages versus those that are better served by tools. the debate comes full circle when one contemplates code generation and methodological tool support for patterns. the authors compare and contrast programming languages, tools, and patterns to assess their relative merits and to clarify their roles in the development process.  craig chambers bill harrison john vlissides
active objects in hybrid  most object-oriented languages are strong on reusability or on strong-typing, but weak on concurrency. in response to this gap, we are developing hybrid, an object-oriented language in which objects are the active entities. objects in hybrid are organized into domains, and concurrent executions into activities. all object communications are based on remote procedure-calls. unstructured sends and accepts are forbidden. to this the mechanisms of delegation and delay queues are added to enable switching and triggering of activities. concurrent subactivities and atomic actions provided for compactness and simplicity. we show how solutions to many important concurrent problems, such a pipelining, constraint management and "administration" can be compactly expressed using these mechanisms.  o. m. nierstrasz
an overview of pcte and pcte+  the pcte project has defined a public tool interface on which software engineering environments can be constructed. the interface definition was put into the public domain in september 1986 and several implementations on several machines now exist. the pcte+ project was set up to define a public tool interface, based on the pcte work, that could also serve for the development of defense and other high-security applications. this paper summarises the current status of pcte activity, presents the principal concepts of pcte and the evolutions that are being proposed in the pcte+ project.  gerard boudier ferdinando gallo regis minot ian thomas
parameter interdependencies of file placement models in a unix system  a file assignment case study of a computer system running unix is presented. a queueing network model of the system is constructed and validated. a modeling technique for the movement of files between and within disks is proposed. a detailed queueing network model is constructed for several file distributions in secondary storage. the interdependencies between the speed of the cpu, the swapping activity, the visit ratios and the multiprogramming level are examined and included in the modeling technique. the models predict the performance of several possible file assignments. the various file assignments are implemented and comparisons between the predicted and actual performance are made. the models are shown to accurately predict user response time.  alfredo de j. perez-davila lawrence w. dowdy
module test case generation  while considerable attention has been given to techniques for developing complex systems as collections of reliable and reusable modules, little is known about testing these modules. in the literature, the special problems of module testing have been largely ignored and few tools or techniques are available to the practicing tester. without effective testing methods, the development and maintenance of reliable and reusable modules is difficult indeed.  we describe an approach for systematic module regression testing. test cases are defined formally using a language based on module traces, and a software tool is used to automatically generate test programs that apply the cases. techniques for test case generation in c and in prolog are presented and illustrated in detail.  d. hoffman c. brealey
designing robust java programs with exceptions  exception handling mechanisms are intended to help developers build robust systems. although an exception handling mechanism provides a basis for structuring source code dealing with unusual situations, little information is available to help guide a developer in the appropriate application of the mechanism. in our experience, this lack of guidance leads to complex exception structures. in this paper, we reflect upon our experiences using the java exception handling mechanism. based on these experiences, we discuss two issues we believe underlie the difficulties encountered: exceptions are a global design problem, and exception sources are often difficult to predict in advance. we then describe a design approach, based on work by litke for ada programs, which we have used to simplify exception structure in existing java programs.  martin p. robillard gail c. murphy
linking codesign and reuse in embedded systems design  this paper presents a complete codesign environment for embedded systems which combines automatic partitioning with reuse from a module database. special emphasis has been put on satisfying the requirements of industrial design practice and on the technical and economic constraints associated with automotive control applications. the object-oriented database architecture allows efficient management of a large number of modules. experimental results from a real-world example demonstrate the viability and advantages of the presented methodology.  m. meerwein c. baumgartner w. glauert
problems with software complexity measurement  theoretical and methodological problems in the development of program-based measures of software complexity are enumerated. three issues are analyzed: the potential confounding influence of non-program factors; the desirable features of complexity measures, and the difficulties in validating complexity measures. the analysis suggests that researchers must find ways to control the effects of non-program factors, perhaps by restricting their focus to a well- defined programming environment. further, both the designers and users of complexity measures must be aware of the inherent limitations of such tools.  robert l. sedlmeyer joseph k. kearney william b. thompson michael a. adler michael a. gray