waashk/acm huggingface dataset:
hybrid slicing: integrating dynamic information with static analysis  program slicing is an effective techniqe for narrowing the focus of attention to the relevant parts of a program during the debugging process. however, imprecision is a problem in static slices, since they are based on all possible executions that reach a given program point rather than the specific execution under which the program is being debugged. dynamic slices, based on the specific execution being debugged, are precise but incur high run-time overhead due to the tracing information that is collected during the program's execution. we present a hybrid slicing technique that integrates dynamic information from a specific execution into a static slice analysis. the hybrid sliceproduced is more precise that the static slice and less costly that the dynamic slice. the technique exploits dynamic information that is readily available during debugging---namely, breakpoint information and the dynamic call graph. this information is integrated into a static slicing analysis to more accurately estimate the potential paths taken by the program. the breakpoints and call/return points, used as reference points, divide the execution path into intervals. by associating each statement in the slice with an execution interval, hybrid slicing provides information as to when a statement was encountered during execution. another attractive feature of our approach is that it allows the user to control the cost of hybrid slicing by limiting the amount of dynamic information used in computing the slice. we implemented the hybrid slicing technique to demonstrate the feasibility of our approach.  rajiv gupta mary lou soffa john howard
model checking java programs (abstract only)  automatic state exploration tools (model checkers) have had some success when applied to protocols and hardware designs, but there are fewer success stories about software. this is unfortunate, since the software problem is worsening even faster than the hardware and protocol problems. model checking of concurrent programs is especially interesting, because they are notoriously difficult to test, analyze, and debug by other methods.  this talk will be a description of our initial efforts to check java programs using a model checker. the model checker supports dynamic allocation, thread creation, and recursive procedures (features that are not necessary for hardware verification), and has some special optimizations and checks tailored to multi-threaded java program. i will also discuss some of the challenges for future efforts in this area.  david dill
compiling object-oriented data intensive applications  processing and analyzing large volumes of data plays an increasingly important role in many domains of scientific research. high-level language and compiler support for developing applications that analyze and process such datasets has, however, been lacking so far.  in this paper, we present a set of language extensions and a prototype compiler for supporting high-level object- oriented programming of data intensive reduction operations over multidimensional data. we have chosen a dialect of java with data-parallel extensions for specifying collection of objects, a parallel for loop, and reduction variables as our source high-level language. our compiler analyzes parallel loops and optimizes the processing of datasets through the use of an existing run-time system, called active data repository (adr). we show how loop fission followed by interprocedural static program slicing can be used by the compiler to extract required information for the run-time system. we present the design of a compiler/n-time interface which allows the compiler to effectively utilize the existing run-time system.  a prototype compiler incorporating these techniques has been developed using the titanium front-end from berkeley. we have evaluated this compiler by comparing the performance of compiler generated code with hand customized adr code for three templates, from the areas of digital microscopy and scientific simulations. our experimental results show that the performance of compiler generated versions is, on the average 21% lower, and in all cases within a factor of two, of the performance of hand coded versions.  renato ferreira gagan agrawal joel saltz
an efficient implementation of self a dynamically-typed object-oriented language based on prototypes  we have developed and implemented techniques that double the performance of dynamically-typed object-oriented languages. our self implementation runs twice as fast as the fastest smalltalk implementation, despite self's lack of classes and explicit variables.  to compensate for the absence of classes, our system uses implementation-level maps to transparently group objects cloned from the same prototype, providing data type information and eliminating the apparent space overhead for prototype- based systems. to compensate for dynamic typing, user-defined control structures, and the lack of explicit variables, our system dynamically compiles multiple versions of a source method, each customized according to its receiver's map. within each version the type of the receiver is fixed, and thus the compiler can statically bind and inline all messages sent to self. message splitting and type prediction extract and preserve even more static type information, allowing the compiler to inline many other messages. inlining dramatically improves performance and eliminates the need to hard- wire low- level methods such as +,==, and iftrue:.  despite inlining and other optimizations, our system still supports interactive programming environments. the system traverses internal dependency lists to invalidate all compiled methods affected by a programming change. the debugger reconstructs inlined stack frames from compiler-generated debugging information, making inlining invisible to the self programmer.  c. chambers d. ungar e. lee
logic optimization and code generation for embedded control applications  we address software optimization for embedded control systems. the esterel language is used as the front-end specification; esterel compiler v6 is used to partition the control circuit and data path; the resulting intermediate representation of the design is a control-data network. this paper emphasizes the optimization of the control circuit portion and the code generation of the logic network. the new control-data network representation has four types of nodes: control, multiplexer, predicate and data expression; the control portion is a multi-valued logic network (mv-network). we use an effective multi-valued logic network optimization package called mvsis for the control optimization. it includes algebraic methods to perform multi-valued algebraic division, factorization and decomposition and logic simplification methods based on observability don't cares. we have developed methods to evaluate a control-data network based on both an mdd and sum-of-products representation of the multi-valued logic functions. the mdd-based approach uses multi-valued intermediate variables and generates code according to the internal bdd structure. the sop-based code is proportional to the number of cubes in the logic network. preliminary results compare the two approaches and the optimization effectiveness.  yunjian jiang robert k. brayton
practical programmer: software teams  i have often heard the phrase, "we see what we know." as technicians, we concentrate on technical ways to manage complexity: abstraction, design techniques, high- level languages, and so on. that is what we know best. but when the tale is told of a project that failed, the blame is often laid not on technical difficulties, but on management and interpersonal problems.  in the last six months, i have seen firsthand how attention to the social organization of a software team can make a big difference in the success of a development project. i work in a "research and development" group. "research" means that some aspects of the project are experimental---we do not know for sure what is going to work. "development" means we are expected to produce high- quality software for real users. so while we want to encourage creative thought, we must pay heed to the lessons of commercial software developers in quality assurance, testing, documentation, and project control.  our all-wise project leader decided we also needed to pay heed to the lessons of sociology. in particular, we began to apply the ideas found in larry constantine's work on the organization of software teams. our efforts have resulted in a team that is productive, flexible, and comfortable. i thought these qualities are unusual enough to merit a column on the subject.  marc rettig
talking about modules and delivery  adding a module system to lisp enhances program security and efficiency, and help the programmer master the complexity of large systems, thus facilitating application and delivery. talk's module system is based on a simple compilation model which takes macros into account and provides a solid basis for automatic module management tools. higher-level structuring entities--- libraries and executables---group modules into deliverable goods. the module system is secure because it validates interfaces, efficient because it separates compilation dependencies from execution dependencies, and useful because it offers a simple processing model, automatic tools, and a graceful transition from development to delivery.  harley davis pierre parquier nitsan seniak
a truly implementation independent gui development tool over the last few years, graphical user interface programming has become increasingly prevalent. many libraries and languages have been developed to simplify this task. additionally, design tools have been created that allow the programmer to "draw" their desired interface and then have code automatically generated. unfortunately, use of these tools locks the programmer into a particular implementation. even if the tool targets a multi-platform library (e.g. tcl/tk or jvm), the flexibility of the result is constrained. we present a truly implementation and platform independent solution. rapid generates ada code targeted to an object-oriented set of graphical user interface specifications with absolutely no implementation dependent information. the pattern used to derive these specifications is an improvement over the "abstract factory" pattern, as it allows both the specification and implementation to take advantage of inheritance. the user can then select an implementation (for example, tcl/tk or jvm) at compile time. rapid itself is also written using the same specifications; therefore it requires no modification to target a new implementation or to use a new implementation itself. rapid is currently being used to design the user interface for a satellite ground station. martin c. carlisle
design considerations in language processing tools for ada  the ada language system (als) is a complete programming environment for the development of ada programs. this paper discusses the design objectives of those portions of the als which support translation and execution of ada programs, particularly the compiler, linker, and program library. the als capabilities for maintenance of software configuration control are highlighted. tradeoffs in the design of the compiler phase structure and intermediate languages are presented.  w. babich l. weissman m. wolfe
dynamic ceiling priorities and ada 95 ada 95 provides dynamic priorities for tasks but ceiling priorities for protected objects are statically assigned by means of a pragma. the semantic complexity as well as the potential inefficiency of any resulting implementation seem to have been the main objections to including dynamic ceilings in ada 95. nevertheless, in frequent scenarios such as multi-moded real-time systems, it is desirable for ceiling priorities to be dynamic, to accommodate the different priority assignments given to tasks in the different modes. this problem is usually worked around by applying the so-called ceiling of ceilings as a static ceiling for all modes, which may result in lower schedulability as extra blocking potentially occurs. in this paper we investigate on how to use a hypothetical _set_ceiling_ dynamic operation, without incurring the risk of semantic ambiguities, and how a multi-moded system can benefit from its existence. jorge real andy wellings
a comparison of two object-oriented design methodologies (abstract only)  with the increasing use of ada* in light of dod directive 5000.31, "the ada programming language shall become the single, common, computer programming language for defense mission- critical applications." there has been an accompanying increase in interest in the proper software engineering techniques to insure that the powerful capabilities of ada will be used to their fullest.  at one ada development site, the design and implementation approach used has been that proposed by grady booch, object- oriented design (ood):  identify the objects of interest in the problem space and their attributes  identify the operations suffered by and required of each object  establish the visibility of each object in relation to other objects  establish the interface of each object  a proposal has been made to compare the deliverables and the end results of the above method with that of david parnas, the software cost reduction method (scr):  identify a list of design decisions for which change cannot be ruled out (data structures, algorithms, etc.) make each design decision the "secret" of one module which comprises sub-programs that cannot be coded without knowledge of the "secret"  design module interfaces that are insensitive to anticipated changes  *ada is a registered trademark of the u.s. department of defense (ada joint program office)  linda rising
design issues and team support: experiences of an ada tool vendor  experiences, insights gained, and lessons learned in the course of developing two ada-based graphic design support tools are summarized. the insights and lessons learned fall into two categories. the fist category involves support for various design methods and approaches, as well as the graphic notation used in providing that support. the second category involves other tool features that are required or desired by teams of software engineers designing mid-sized or large ada systems.  b. crawford d. baker
designing specification languages for process control systems: lessons learned and steps to the future  previously, we defined a blackbox formal system modeling language called rsml (requirements state machine language). the language was developed over several years while specifying the system requirements for a collision avoidance system for commercial passenger aircraft. during the language development, we received continual feedback and evaluation by faa employees and industry representatives, which helped us to produce a specification language that is easily learned and used by application experts.  since the completion of the rsml project, we have continued our research on specification languages. this research is part of a larger effort to investigate the more general problem of providing tools to assist in developing embedded systems. our latest experimental toolset is called spectrm (specification tools and requirements methodology), and the formal specification language is spectrm-rl (spectrm requirements language).  this paper describes what we have learned from our use of rsml and how those lessons were applied to the design of spectrm-rl. we discuss our goals for spectrm-rl and the design features that support each of these goals.  nancy g. leveson mats p. e. heimdahl jon damon reese
module: an encapsulation mechanism for specifying and implementing abstract data types  an encapsulation mechanism, the module, for specifying abstract data types is described. the module employs a constructive specification method for specifying abstract data types. the constructive method consists of two specifications: a logical structure specification and a semantics of operations specification. the specification and implementation of a nontrivial data type, a symboltable data type, is given and proof of implementation correctness is discussed and illustrated.  billy g. claybrook marvin p. wyckoff
an algebra for program fragments  program fragments are described either by strings in the concrete syntax or by constructor applications in the abstract syntax. by defining conversions between these forms, both may be intermixed. program fragments are constructed by terminal and nonterminal symbols from the grammar and by variables having program fragments as values. basic operations such as valuetransfer, composition and decomposition are defined for program fragments allowing more complicated operations to be implemented. usual operations such as testing for equality are defined, and in addition more specialized operations such as testing that a program fragment is derivable from another and converting program fragments in concrete form to abstract form are defined. by introducing regular expressions in the grammar these may be used in program fragments in concrete form. by defining constructors for regular expressions these may also be used in program fragments in abstract form.  bent bruun kristensen ole lehrmann madsen birger møller-pedersen kristen nygaard
pmdb - a project master database for software engineering environments  although the use of software engineering environments (see) results in increased software productivity, current sees are still in the infant stages and lack critical characteristics such as an integrated project database which stores all data pertinent to a project, i.e., resources, products, management information, etc, and which provides easy access to its data.  driven by projects' needs and motivated by the experiences acquired in the building of the trw software development environment, an effort was set forth, as part of an internal research and development project, to study the issues associated with an environment database, with the overall objective of defining, designing and developing a project master database (pmdb) as an integrated part of a software development environment. this paper reports the initial results of this work; it describes our pmdb model and discusses some of the technical issues in the definition and design of an environment database.  maria h. penedo e. don stuckle
processor modeling and code selection for retargetable compilation  embedded processors in electronic systems typically are tuned to a few applications. development of processor-specific compilers is prohibitively expensive and, as a result, such compilers, if existing, yield code of an unacceptable quality. to improve this code quality, we developed a processor model that captures the connectivity, the parallelism, and all architectural peculiarities of an embedded processor. we also implemented a retargetable and optimizing compiler working on this model. we present the graph-based processor model, and formally define the code generation task as binding the intermediate representation of an application to this model. we also present a new method for code selection, based on this processor model, that is capable of handling directed acyclic graphs instead of trees.  j. van praet d. lanneer w. geurts g. goossens
workload decomposition for particle simulation applications on hierarchical distributed-shared memory parallel systems with integration of hpf and openmp  a crucial issue in programming hierarchical distributed-shared memory systems is the _workload decomposition_. in this paper we address this issue in the framework of porting typical _particle in cell_ (pic) applications on hierarchical distributed-shared memory parallel systems. the workload decomposition we have devised consists in a two-stage procedure: a higher- level decomposition among the computational nodes, and a lower-level one among the processors of each computational node. we have implemented the described work decomposition without large programming effort by using and integrating the high-level languages high performance fortran and openmp.  sergio briguglio beniamino di martino gregorio vlad
using shape analysis to reduce finite-state models of concurrent java programs  finite-state verification (e.g., model checking) provides a powerful means to detect concurrency errors, which are often subtle and difficult to reproduce. nevertheless, widespread use of this technology by developers is unlikely until tools provide automated support for extracting the required finite-state models directly from program source. unfortunately, the dynamic features of modern languages such as java complicate the construction of compact finite- state models for verification. in this article, we show how shape analysis, which has traditionally been used for computing alias information in optimizers, can be used to greatly reduce the size of finite- state models of concurrent java programs by determining which heap-allocated variables are accessible only by a single thread, and which shared variables are protected by locks. we also provide several other state-space reductions based on the semantics of java monitors. a prototype of the reductions demonstrates their effectiveness.  james c. corbett
e pluribus unum: oopl selection usually legacies act as strong amalgamating forces and are thus beneficial to systems and theories. however, as time passes through, even legacies must be reviewed in order to benefit from changes. although several sound models has been produced by software engineers in the last 25 years, a large amount of software is still produced and maintained using aged paradigms and methods (if any) and cobol/fortran generation tools. the underlying idea seems to be "why change it if it works?". nevertheless it seems too that time for changes has come. the oo paradigm is really strong and useful and has been showed appropriate for almost any conceivable software system. besides, actual programmers and analysts are formed under this paradigm. so it seems foreseeable a consistent conversion to oo paradigm. what still doesn't seem to be clear is how adequate are the actual oop languages to support the paradigm, and what is the comparative effort involved in mastering them and their associated environments. this paper reports the heuristics and observations resulting from a simple experiment formulated to explore how adequate are the languages c++, eiffel, and ada 95 to implement oo designed systems. gabriela o. de vivo marco de vivo germinal isern
constant time interpretation for shallow-bound variables in the presence of mixed special/local declarations  the semantics of variables in lisp are usually centered around the compiled- code environment; in many shallow- bound systems, local variables are implemented as stack-slots in the compiled environment, but are merely converted to special (or "fluid") variables by the interpreter. this paper shows a method for separating local from special bindings when interpreting, such that the time to evaluate a reference to a variable is bounded by a modestly small constant; comparison is made to methods which require a time proportional to the number of variables present in the function being interpreted. notations: a maclisp style is used for program examples; thus defun rather than define, let often in preference to lambda, and semi-colon for noting commentary. without loss of generality, we refer to all variable binding, whether from let, lambda, prog, or whatever, as "lambda binding".  jon l white
function and context  this paper tackles three areas of difficulty in apl. the first is the subjection to apl syntax of the work presently performed by system commands under user intervention. the second is the growing diversity of object types noted by crick. the third arises from the matter of assigning functions raised by iverson and wooster. all three areas are addressed by proposed extensions to the definition and concept of functions. the extended definition is shown to incorporate workspaces, groups, workspace libraries, file subsystems and namespaces as special cases, and to make certain system commands redundant.  stephen taylor