Datasets:

sumuks

/

arxiv_dataset

like 0

Termination analysis of logic programs using acceptability with general term orders

http://arxiv.org/abs/cs/0011025v1

http://arxiv.org/abs/cs/0011025v1

http://arxiv.org/pdf/cs/0011025v1

2000-11-17

2000-11-17

We present a new approach to termination analysis of logic programs. The essence of the approach is that we make use of general term-orderings (instead of level mappings), like it is done in transformational approaches to logic program termination analysis, but that we apply these orderings directly to the logic program and not to the term-rewrite system obtained through some transformation. We define some variants of acceptability, based on general term-orderings, and show how they are equivalent to LD-termination. We develop a demand driven, constraint-based approach to verify these acceptability-variants. The advantage of the approach over standard acceptability is that in some cases, where complex level mappings are needed, fairly simple term-orderings may be easily generated. The advantage over transformational approaches is that it avoids the transformation step all together.

technical report of K.U.Leuven

cs.PL

Apache web server execution tracing using Third Eye

http://arxiv.org/abs/cs/0011022v1

http://arxiv.org/abs/cs/0011022v1

http://arxiv.org/pdf/cs/0011022v1

2000-11-16

2000-11-16

Testing of modern software systems that integrate many components developed by different teams is a difficult task. Third Eye is a framework for tracing and validating software systems using application domain events. We use formal descriptions of the constraints between events to identify violations in execution traces. Third Eye is a flexible and modular framework that can be used in different products. We present the validation of the Apache Web Server access policy implementation. The results indicate that our tool is a helpful addition to software development infrastructure.

In M. Ducasse (ed), proceedings of the Fourth International Workshop on Automated Debugging (AADEBUG 2000), August 2000, Munich. cs.SE/0010035 5 pages, 2 figures

cs.SE

On-the-fly Query-Based Debugging with Examples

http://arxiv.org/abs/cs/0011021v1

http://arxiv.org/abs/cs/0011021v1

http://arxiv.org/pdf/cs/0011021v1

2000-11-16

2000-11-16

Program errors are hard to find because of the cause-effect gap between the time when an error occurs and the time when the error becomes apparent to the programmer. Although debugging techniques such as conditional and data breakpoints help to find error causes in simple cases, they fail to effectively bridge the cause-effect gap in many situations. Query-based debuggers offer programmers an effective tool that provides instant error alert by continuously checking inter-object relationships while the debugged program is running. To enable the query-based debugger in the middle of program execution in a portable way, we propose efficient Java class file instrumentation and discuss alternative techniques. Although the on-the-fly debugger has a higher overhead than a dynamic query-based debugger, it offers additional interactive power and flexibility while maintaining complete portability. To speed up dynamic query evaluation, our debugger implemented in portable Java uses a combination of program instrumentation, load-time code generation, query optimization, and incremental reevaluation. This paper discusses on-the-fly debugging and demonstrates the query-based debugger application for debugging Java gas tank applet as well as SPECjvm98 suite applications.

In M. Ducasse (ed), proceedings of the Fourth International Workshop on Automated Debugging (AADEBUG 2000), August 2000, Munich. cs.SE/0010035 14 pages, 6 figures

cs.SE

Automatic Debugging Support for UML Designs

http://arxiv.org/abs/cs/0011017v1

http://arxiv.org/abs/cs/0011017v1

http://arxiv.org/pdf/cs/0011017v1

2000-11-13

2000-11-13

Design of large software systems requires rigorous application of software engineering methods covering all phases of the software process. Debugging during the early design phases is extremely important, because late bug-fixes are expensive. In this paper, we describe an approach which facilitates debugging of UML requirements and designs. The Unified Modeling Language (UML) is a set of notations for object-orient design of a software system. We have developed an algorithm which translates requirement specifications in the form of annotated sequence diagrams into structured statecharts. This algorithm detects conflicts between sequence diagrams and inconsistencies in the domain knowledge. After synthesizing statecharts from sequence diagrams, these statecharts usually are subject to manual modification and refinement. By using the ``backward'' direction of our synthesis algorithm, we are able to map modifications made to the statechart back into the requirements (sequence diagrams) and check for conflicts there. Fed back to the user conflicts detected by our algorithm are the basis for deductive-based debugging of requirements and domain theory in very early development stages. Our approach allows to generate explanations on why there is a conflict and which parts of the specifications are affected.

In M. Ducasse (ed), proceedings of the Fourth International Workshop on Automated Debugging (AADEBUG 2000), August 2000, Munich. cs.SE/0010035

cs.SE

Extension Language Automation of Embedded System Debugging

http://arxiv.org/abs/cs/0011010v1

http://arxiv.org/abs/cs/0011010v1

http://arxiv.org/pdf/cs/0011010v1

2000-11-06

2000-11-06

Embedded systems contain several layers of target processing abstraction. These layers include electronic circuit, binary machine code, mnemonic assembly code, and high-level procedural and object-oriented abstractions. Physical and temporal constraints and artifacts within physically embedded systems make it impossible for software engineers to operate at a single layer of processor abstraction. The Luxdbg embedded system debugger exposes these layers to debugger users, and it adds an additional layer, the extension language layer, that allows users to extend both the debugger and its target processor capabilities. Tcl is Luxdbg's extension language. Luxdbg users can apply Tcl to automate interactive debugging steps, to redirect and to interconnect target processor input-output facilities, to schedule multiple processor execution, to log and to react to target processing exceptions, and to automate target system testing. Inclusion of an extension language like Tcl in a debugger promises additional advantages for distributed debugging, where debuggers can pass extension language expressions across computer networks.

In M. Ducasse (ed), proceedings of the Fourth International Workshop on Automated Debugging (AADebug 2000), August 2000, Munich. cs.SE/0010035

cs.SE

A Lambda-Calculus with letrec, case, constructors and non-determinism

http://arxiv.org/abs/cs/0011008v1

http://arxiv.org/abs/cs/0011008v1

http://arxiv.org/pdf/cs/0011008v1

2000-11-06

2000-11-06

A non-deterministic call-by-need lambda-calculus \calc with case, constructors, letrec and a (non-deterministic) erratic choice, based on rewriting rules is investigated. A standard reduction is defined as a variant of left-most outermost reduction. The semantics is defined by contextual equivalence of expressions instead of using $\alpha\beta(\eta)$-equivalence. It is shown that several program transformations are correct, for example all (deterministic) rules of the calculus, and in addition the rules for garbage collection, removing indirections and unique copy. This shows that the combination of a context lemma and a meta-rewriting on reductions using complete sets of commuting (forking, resp.) diagrams is a useful and successful method for providing a semantics of a functional programming language and proving correctness of program transformations.

cs.PL

Execution replay and debugging

http://arxiv.org/abs/cs/0011006v1

http://arxiv.org/abs/cs/0011006v1

http://arxiv.org/pdf/cs/0011006v1

2000-11-06

2000-11-06

As most parallel and distributed programs are internally non-deterministic -- consecutive runs with the same input might result in a different program flow -- vanilla cyclic debugging techniques as such are useless. In order to use cyclic debugging tools, we need a tool that records information about an execution so that it can be replayed for debugging. Because recording information interferes with the execution, we must limit the amount of information and keep the processing of the information fast. This paper contains a survey of existing execution replay techniques and tools.

In M. Ducasse (ed), proceedings of the Fourth International Workshop on Automated Debugging (AADebug 2000), August 2000, Munich. cs.SE/0010035

cs.SE

Non-intrusive on-the-fly data race detection using execution replay

http://arxiv.org/abs/cs/0011005v1

http://arxiv.org/abs/cs/0011005v1

http://arxiv.org/pdf/cs/0011005v1

2000-11-06

2000-11-06

This paper presents a practical solution for detecting data races in parallel programs. The solution consists of a combination of execution replay (RecPlay) with automatic on-the-fly data race detection. This combination enables us to perform the data race detection on an unaltered execution (almost no probe effect). Furthermore, the usage of multilevel bitmaps and snooped matrix clocks limits the amount of memory used. As the record phase of RecPlay is highly efficient, there is no need to switch it off, hereby eliminating the possibility of Heisenbugs because tracing can be left on all the time.

In M. Ducasse (ed), proceedings of the Fourth International Workshop on Automated Debugging (AAdebug 2000), August 2000, Munich. cs.SE/0010035

cs.SE

Collecting Graphical Abstract Views of Mercury Program Executions

http://arxiv.org/abs/cs/0010038v1

http://arxiv.org/abs/cs/0010038v1

http://arxiv.org/pdf/cs/0010038v1

2000-10-31

2000-10-31

A program execution monitor is a program that collects and abstracts information about program executions. The "collect" operator is a high level, general purpose primitive which lets users implement their own monitors. "Collect" is built on top of the Mercury trace. In previous work, we have demonstrated how this operator can be used to efficiently collect various kinds of statistics about Mercury program executions. In this article we further demonstrate the expressive power and effectiveness of "collect" by providing more monitor examples. In particular, we show how to implement monitors that generate graphical abstractions of program executions such as proof trees, control flow graphs and dynamic call graphs. We show how those abstractions can be easily modified and adapted, since those monitors only require several dozens of lines of code. Those abstractions are intended to serve as front-ends of software visualization tools. Although "collect" is currently implemented on top of the Mercury trace, none of its underlying concepts depend of Mercury and it can be implemented on top of any tracer for any programming language.

In M. Ducasse (ed), proceedings of the Fourth International Workshop on Automated Debugging (AADEBUG 2000), August 2000, Munich. cs.SE/0010035

cs.SE

Proceedings of the Fourth International Workshop on Automated Debugging (AADEBUG 2000)

http://arxiv.org/abs/cs/0010035v2

http://arxiv.org/abs/cs/0010035v2

http://arxiv.org/pdf/cs/0010035v2

2000-10-30

2001-01-23

Over the past decades automated debugging has seen major achievements. However, as debugging is by necessity attached to particular programming paradigms, the results are scattered. The aims of the workshop are to gather common themes and solutions across programming communities, and to cross-fertilize ideas. AADEBUG 2000 in Munich follows AADEBUG'93 in Linkoeping, Sweden; AADEBUG'95 in Saint Malo, France; AADEBUG'97 in Linkoeping, Sweden.

2 invited talks, 3 articles with demonstration description, 10 articles, 3 demonstration descriptions, 5 poster abstracts

cs.SE

Static Analysis Techniques for Equational Logic Programming

http://arxiv.org/abs/cs/0010034v1

http://arxiv.org/abs/cs/0010034v1

http://arxiv.org/pdf/cs/0010034v1

2000-10-27

2000-10-27

An equational logic program is a set of directed equations or rules, which are used to compute in the obvious way (by replacing equals with ``simpler'' equals). We present static analysis techniques for efficient equational logic programming, some of which have been implemented in $LR^2$, a laboratory for developing and evaluating fast, efficient, and practical rewriting techniques. Two novel features of $LR^2$ are that non-left-linear rules are allowed in most contexts and it has a tabling option based on the congruence-closure based algorithm to compute normal forms. Although, the focus of this research is on the tabling approach some of the techniques are applicable to the untabled approach as well. Our presentation is in the context of $LR^2$, which is an interpreter, but some of the techniques apply to compilation as well.

Appeared in 1st ACM SIGPLAN Workshop on Rule-based Programming (RULE 2000)

cs.LO

Sequence-Based Abstract Interpretation of Prolog

http://arxiv.org/abs/cs/0010028v1

http://arxiv.org/abs/cs/0010028v1

http://arxiv.org/pdf/cs/0010028v1

2000-10-19

2000-10-19

Many abstract interpretation frameworks and analyses for Prolog have been proposed, which seek to extract information useful for program optimization. Although motivated by practical considerations, notably making Prolog competitive with imperative languages, such frameworks fail to capture some of the control structures of existing implementations of the language. In this paper we propose a novel framework for the abstract interpretation of Prolog which handles the depth-first search rule and the cut operator. It relies on the notion of substitution sequence to model the result of the execution of a goal. The framework consists of (i) a denotational concrete semantics, (ii) a safe abstraction of the concrete semantics defined in terms of a class of post-fixpoints, and (iii) a generic abstract interpretation algorithm. We show that traditional abstract domains of substitutions may easily be adapted to the new framework, and provide experimental evidence of the effectiveness of our approach. We also show that previous work on determinacy analysis, that was not expressible by existing abstract interpretation frameworks, can be seen as an instance of our framework.

62 pages. To appear in the journal "Theory and Practice of Logic Programming"

cs.LO

Towards rule-based visual programming of generic visual systems

http://arxiv.org/abs/cs/0010016v1

http://arxiv.org/abs/cs/0010016v1

http://arxiv.org/pdf/cs/0010016v1

2000-10-10

2000-10-10

This paper illustrates how the diagram programming language DiaPlan can be used to program visual systems. DiaPlan is a visual rule-based language that is founded on the computational model of graph transformation. The language supports object-oriented programming since its graphs are hierarchically structured. Typing allows the shape of these graphs to be specified recursively in order to increase program security. Thanks to its genericity, DiaPlan allows to implement systems that represent and manipulate data in arbitrary diagram notations. The environment for the language exploits the diagram editor generator DiaGen for providing genericity, and for implementing its user interface and type checker.

15 pages, 16 figures contribution to the First International Workshop on Rule-Based Programming (RULE'2000), September 19, 2000, Montreal, Canada

cs.PL

On Exponential-Time Completeness of the Circularity Problem for Attribute Grammars

http://arxiv.org/abs/cs/0010015v1

http://arxiv.org/abs/cs/0010015v1

http://arxiv.org/pdf/cs/0010015v1

2000-10-10

2000-10-10

Attribute grammars (AGs) are a formal technique for defining semantics of programming languages. Existing complexity proofs on the circularity problem of AGs are based on automata theory, such as writing pushdown acceptor and alternating Turing machines. They reduced the acceptance problems of above automata, which are exponential-time (EXPTIME) complete, to the AG circularity problem. These proofs thus show that the circularity problem is EXPTIME-hard, at least as hard as the most difficult problems in EXPTIME. However, none has given a proof for the EXPTIME-completeness of the problem. This paper first presents an alternating Turing machine for the circularity problem. The alternating Turing machine requires polynomial space. Thus, the circularity problem is in EXPTIME and is then EXPTIME-complete.

7 pages

cs.PL

An Approach to the Implementation of Overlapping Rules in Standard ML

http://arxiv.org/abs/cs/0010009v1

http://arxiv.org/abs/cs/0010009v1

http://arxiv.org/pdf/cs/0010009v1

2000-10-03

2000-10-03

We describe an approach to programming rule-based systems in Standard ML, with a focus on so-called overlapping rules, that is rules that can still be active when other rules are fired. Such rules are useful when implementing rule-based reactive systems, and to that effect we show a simple implementation of Loyall's Active Behavior Trees, used to control goal-directed agents in the Oz virtual environment. We discuss an implementation of our framework using a reactive library geared towards implementing those kind of systems.

13 pages. Presented at RULE 2000, First International Workshop on Rule-Based Programming, Montreal, Canada

cs.PL

The Light Lexicographic path Ordering

http://arxiv.org/abs/cs/0010008v1

http://arxiv.org/abs/cs/0010008v1

http://arxiv.org/pdf/cs/0010008v1

2000-10-03

2000-10-03

We introduce syntactic restrictions of the lexicographic path ordering to obtain the Light Lexicographic Path Ordering. We show that the light lexicographic path ordering leads to a characterisation of the functions computable in space bounded by a polynomial in the size of the inputs.

cs.PL

From Syntactic Theories to Interpreters: A Specification Language and Its Compilation

http://arxiv.org/abs/cs/0009030v1

http://arxiv.org/abs/cs/0009030v1

http://arxiv.org/pdf/cs/0009030v1

2000-09-29

2000-09-29

Recent years have seen an increasing need of high-level specification languages and tools generating code from specifications. In this paper, we introduce a specification language, {\splname}, which is tailored to the writing of syntactic theories of language semantics. More specifically, the language supports specifying primitive notions such as dynamic constraints, contexts, axioms, and inference rules. We also introduce a system which generates interpreters from {\splname} specifications. A prototype system is implemented and has been tested on a number of examples, including a syntactic theory for Verilog.

Accepted in Rule-based Programming Workshop, 2000, 16 pages

cs.PL

The Concurrent Language Aldwych

http://arxiv.org/abs/cs/0009029v1

http://arxiv.org/abs/cs/0009029v1

http://arxiv.org/pdf/cs/0009029v1

2000-09-29

2000-09-29

Aldwych is proposed as the foundation of a general purpose language for parallel applications. It works on a rule-based principle, and has aspects variously of concurrent functional, logic and object-oriented languages, yet it forms an integrated whole. It is intended to be applicable both for small-scale parallel programming, and for large-scale open systems.

Presented at RULE 2000, First International Workshop on Rule-Based Programming, Montreal, Canada

cs.PL

Polynomial-time Computation via Local Inference Relations

http://arxiv.org/abs/cs/0007020v2

http://arxiv.org/abs/cs/0007020v2

http://arxiv.org/pdf/cs/0007020v2

2000-07-13

2000-07-14

We consider the concept of a local set of inference rules. A local rule set can be automatically transformed into a rule set for which bottom-up evaluation terminates in polynomial time. The local-rule-set transformation gives polynomial-time evaluation strategies for a large variety of rule sets that cannot be given terminating evaluation strategies by any other known automatic technique. This paper discusses three new results. First, it is shown that every polynomial-time predicate can be defined by an (unstratified) local rule set. Second, a new machine-recognizable subclass of the local rule sets is identified. Finally we show that locality, as a property of rule sets, is undecidable in general.

22 pages. Appeared in Knowledge Representation and Reasoning,1993. Submitted to ACM Transactions on Computational Logic Correction: original conference appearance was 1992, not 1993

cs.LO

Applying Constraint Handling Rules to HPSG

http://arxiv.org/abs/cs/0007013v1

http://arxiv.org/abs/cs/0007013v1

http://arxiv.org/pdf/cs/0007013v1

2000-07-07

2000-07-07

Constraint Handling Rules (CHR) have provided a realistic solution to an over-arching problem in many fields that deal with constraint logic programming: how to combine recursive functions or relations with constraints while avoiding non-termination problems. This paper focuses on some other benefits that CHR, specifically their implementation in SICStus Prolog, have provided to computational linguists working on grammar design tools. CHR rules are applied by means of a subsumption check and this check is made only when their variables are instantiated or bound. The former functionality is at best difficult to simulate using more primitive coroutining statements such as SICStus when/2, and the latter simply did not exist in any form before CHR. For the sake of providing a case study in how these can be applied to grammar development, we consider the Attribute Logic Engine (ALE), a Prolog preprocessor for logic programming with typed feature structures, and its extension to a complete grammar development system for Head-driven Phrase Structure Grammar (HPSG), a popular constraint-based linguistic theory that uses typed feature structures. In this context, CHR can be used not only to extend the constraint language of feature structure descriptions to include relations in a declarative way, but also to provide support for constraints with complex antecedents and constraints on the co-occurrence of feature values that are necessary to interpret the type system of HPSG properly.

To appear, Proceedings of First Workshop on Rule-Based Constraint Reasoning and Programming, CL2000; 14 pages

cs.CL

Compiling Language Definitions: The ASF+SDF Compiler

http://arxiv.org/abs/cs/0007008v1

http://arxiv.org/abs/cs/0007008v1

http://arxiv.org/pdf/cs/0007008v1

2000-07-06

2000-07-06

The ASF+SDF Meta-Environment is an interactive language development environment whose main application areas are definition of domain-specific languages, generation of program analysis and transformation tools, production of software renovation tools, and general specification and prototyping. It uses conditional rewrite rules to define the dynamic semantics and other tool-oriented aspects of languages, so the effectiveness of the generated tools is critically dependent on the quality of the rewrite rule implementation. The ASF+SDF rewrite rule compiler generates C code, thus taking advantage of C's portability and the sophisticated optimization capabilities of current C compilers as well as avoiding potential abstract machine interface bottlenecks. It can handle large (10 000+ rule) language definitions and uses an efficient run-time storage scheme capable of handling large (1 000 000+ node) terms. Term storage uses maximal subterm sharing (hash-consing), which turns out to be more effective in the case of ASF+SDF than in Lisp or SML. Extensive benchmarking has shown the time and space performance of the generated code to be as good as or better than that of the best current rewrite rule and functional language compilers.

36 pages, 5 figures

ACM Transactions on Programming Languages and Systems 24 4 (July 2002) 334-368

cs.PL

Constraint Exploration and Envelope of Simulation Trajectories

http://arxiv.org/abs/cs/0007001v1

http://arxiv.org/abs/cs/0007001v1

http://arxiv.org/pdf/cs/0007001v1

2000-07-03

2000-07-03

The implicit theory that a simulation represents is precisely not in the individual choices but rather in the 'envelope' of possible trajectories - what is important is the shape of the whole envelope. Typically a huge amount of computation is required when experimenting with factors bearing on the dynamics of a simulation to tease out what affects the shape of this envelope. In this paper we present a methodology aimed at systematically exploring this envelope. We propose a method for searching for tendencies and proving their necessity relative to a range of parameterisations of the model and agents' choices, and to the logic of the simulation language. The exploration consists of a forward chaining generation of the trajectories associated to and constrained by such a range of parameterisations and choices. Additionally, we propose a computational procedure that helps implement this exploration by translating a Multi Agent System simulation into a constraint-based search over possible trajectories by 'compiling' the simulation rules into a more specific form, namely by partitioning the simulation rules using appropriate modularity in the simulation. An example of this procedure is exhibited. Keywords: Constraint Search, Constraint Logic Programming, Proof, Emergence, Tendencies

15 pages, To be presented at the First Workshop on Rule-Based Constraint Reasoning and Programming at the First International Conference on Computational Logic, London, UK, 24th to 28th July, 2000

cs.PL

Type Classes and Constraint Handling Rules

http://arxiv.org/abs/cs/0006034v1

http://arxiv.org/abs/cs/0006034v1

http://arxiv.org/pdf/cs/0006034v1

2000-06-26

2000-06-26

Type classes are an elegant extension to traditional, Hindley-Milner based typing systems. They are used in modern, typed languages such as Haskell to support controlled overloading of symbols. Haskell 98 supports only single-parameter and constructor type classes. Other extensions such as multi-parameter type classes are highly desired but are still not officially supported by Haskell. Subtle issues arise with extensions, which may lead to a loss of feasible type inference or ambiguous programs. A proper logical basis for type class systems seems to be missing. Such a basis would allow extensions to be characterised and studied rigorously. We propose to employ Constraint Handling Rules as a tool to study and develop type class systems in a uniform way.

14 pages, Workshop on Rule-Based Constraint Reasoning and Programming (http://www.informatik.uni-muenchen.de/~fruehwir/cl2000r.html)

cs.PL

Verifying Termination and Error-Freedom of Logic Programs with block Declarations

http://arxiv.org/abs/cs/0006033v1

http://arxiv.org/abs/cs/0006033v1

http://arxiv.org/pdf/cs/0006033v1

2000-06-23

2000-06-23

We present verification methods for logic programs with delay declarations. The verified properties are termination and freedom from errors related to built-ins. Concerning termination, we present two approaches. The first approach tries to eliminate the well-known problem of speculative output bindings. The second approach is based on identifying the predicates for which the textual position of an atom using this predicate is irrelevant with respect to termination. Three features are distinctive of this work: it allows for predicates to be used in several modes; it shows that block declarations, which are a very simple delay construct, are sufficient to ensure the desired properties; it takes the selection rule into account, assuming it to be as in most Prolog implementations. The methods can be used to verify existing programs and assist in writing new programs.

to be published in Theory and Practice of Logic Programming, 40 pages, 10 figures

cs.LO

Multimethods and separate static typechecking in a language with C++-like object model

http://arxiv.org/abs/cs/0005033v1

http://arxiv.org/abs/cs/0005033v1

http://arxiv.org/pdf/cs/0005033v1

2000-05-31

2000-05-31

The goal of this paper is the description and analysis of multimethod implementation in a new object-oriented, class-based programming language called OOLANG. The implementation of the multimethod typecheck and selection, deeply analyzed in the paper, is performed in two phases in order to allow static typechecking and separate compilation of modules. The first phase is performed at compile time, while the second is executed at link time and does not require the modules' source code. OOLANG has syntax similar to C++; the main differences are the absence of pointers and the realization of polymorphism through subsumption. It adopts the C++ object model and supports multiple inheritance as well as virtual base classes. For this reason, it has been necessary to define techniques for realigning argument and return value addresses when performing multimethod invocations.

15 pages, 18 figures

cs.PL

C++ programming language for an abstract massively parallel SIMD architecture

http://arxiv.org/abs/cs/0005023v1

http://arxiv.org/abs/cs/0005023v1

http://arxiv.org/pdf/cs/0005023v1

2000-05-19

2000-05-19

The aim of this work is to define and implement an extended C++ language to support the SIMD programming paradigm. The C++ programming language has been extended to express all the potentiality of an abstract SIMD machine consisting of a central Control Processor and a N-dimensional toroidal array of Numeric Processors. Very few extensions have been added to the standard C++ with the goal of minimising the effort for the programmer in learning a new language and to keep very high the performance of the compiled code. The proposed language has been implemented as a porting of the GNU C++ Compiler on a SIMD supercomputer.

10 pages

cs.PL

On Modular Termination Proofs of General Logic Programs

http://arxiv.org/abs/cs/0005018v2

http://arxiv.org/abs/cs/0005018v2

http://arxiv.org/pdf/cs/0005018v2

2000-05-11

2001-07-30

We propose a modular method for proving termination of general logic programs (i.e., logic programs with negation). It is based on the notion of acceptable programs, but it allows us to prove termination in a truly modular way. We consider programs consisting of a hierarchy of modules and supply a general result for proving termination by dealing with each module separately. For programs which are in a certain sense well-behaved, namely well-moded or well-typed programs, we derive both a simple verification technique and an iterative proof method. Some examples show how our system allows for greatly simplified proofs.

29 pages. To appear in Theory and Practice of Logic Programming

cs.LO

A Denotational Semantics for First-Order Logic

http://arxiv.org/abs/cs/0005008v1

http://arxiv.org/abs/cs/0005008v1

http://arxiv.org/pdf/cs/0005008v1

2000-05-08

2000-05-08

In Apt and Bezem [AB99] (see cs.LO/9811017) we provided a computational interpretation of first-order formulas over arbitrary interpretations. Here we complement this work by introducing a denotational semantics for first-order logic. Additionally, by allowing an assignment of a non-ground term to a variable we introduce in this framework logical variables. The semantics combines a number of well-known ideas from the areas of semantics of imperative programming languages and logic programming. In the resulting computational view conjunction corresponds to sequential composition, disjunction to ``don't know'' nondeterminism, existential quantification to declaration of a local variable, and negation to the ``negation as finite failure'' rule. The soundness result shows correctness of the semantics with respect to the notion of truth. The proof resembles in some aspects the proof of the soundness of the SLDNF-resolution.

17 pages. Invited talk at the Computational Logic Conference (CL 2000). To appear in Springer-Verlag Lecture Notes in Computer Science

cs.PL

Application Software, Domain-Specific Languages, and Language Design Assistants

http://arxiv.org/abs/cs/0005002v1

http://arxiv.org/abs/cs/0005002v1

http://arxiv.org/pdf/cs/0005002v1

2000-05-03

2000-05-03

While application software does the real work, domain-specific languages (DSLs) are tools to help produce it efficiently, and language design assistants in turn are meta-tools to help produce DSLs quickly. DSLs are already in wide use (HTML for web pages, Excel macros for spreadsheet applications, VHDL for hardware design, ...), but many more will be needed for both new as well as existing application domains. Language design assistants to help develop them currently exist only in the basic form of language development systems. After a quick look at domain-specific languages, and especially their relationship to application libraries, we survey existing language development systems and give an outline of future language design assistants.

To be presented at SSGRR 2000, L'Aquila, Italy

in Proceedings SSGRR 2000 International Conference on Advances in Infrastructure for Electronic Business, Science, and Education on the Internet

cs.PL

Task Frames

http://arxiv.org/abs/cs/0004011v1

http://arxiv.org/abs/cs/0004011v1

http://arxiv.org/pdf/cs/0004011v1

2000-04-19

2000-04-19

Forty years ago Dijkstra introduced the current conventional execution of routines. It places activation frames onto a stack. Each frame is the internal state of an executing routine. The resulting application execution is not easily helped by an external system. This presentation proposes an alternative execution of routines. It places task frames onto the stack. A task frame is the call of a routine to be executed. The feasibility of the alternative execution is demonstrated by a crude implementation. As described elsewhere, an application which executes in terms of tasks can be provided by an external system with a transparent reliable, distributed, heterogeneous, adaptive, dynamic, real-time, parallel, secure or other execution. By extending the crude implementation, this presentation outlines a simple transparent parallel execution.

cs.PL

On Redundancy Elimination Tolerant Scheduling Rules

http://arxiv.org/abs/cs/0004006v1

http://arxiv.org/abs/cs/0004006v1

http://arxiv.org/pdf/cs/0004006v1

2000-04-17

2000-04-17

In (Ferrucci, Pacini and Sessa, 1995) an extended form of resolution, called Reduced SLD resolution (RSLD), is introduced. In essence, an RSLD derivation is an SLD derivation such that redundancy elimination from resolvents is performed after each rewriting step. It is intuitive that redundancy elimination may have positive effects on derivation process. However, undesiderable effects are also possible. In particular, as shown in this paper, program termination as well as completeness of loop checking mechanisms via a given selection rule may be lost. The study of such effects has led us to an analysis of selection rule basic concepts, so that we have found convenient to move the attention from rules of atom selection to rules of atom scheduling. A priority mechanism for atom scheduling is built, where a priority is assigned to each atom in a resolvent, and primary importance is given to the event of arrival of new atoms from the body of the applied clause at rewriting time. This new computational model proves able to address the study of redundancy elimination effects, giving at the same time interesting insights into general properties of selection rules. As a matter of fact, a class of scheduling rules, namely the specialisation independent ones, is defined in the paper by using not trivial semantic arguments. As a quite surprising result, specialisation independent scheduling rules turn out to coincide with a class of rules which have an immediate structural characterisation (named stack-queue rules). Then we prove that such scheduling rules are tolerant to redundancy elimination, in the sense that neither program termination nor completeness of equality loop check is lost passing from SLD to RSLD.

53 pages, to appear on TPLP

cs.PL

Programming in Alma-0, or Imperative and Declarative Programming Reconciled

http://arxiv.org/abs/cs/0004002v1

http://arxiv.org/abs/cs/0004002v1

http://arxiv.org/pdf/cs/0004002v1

2000-04-05

2000-04-05

In (Apt et al, TOPLAS 1998) we introduced the imperative programming language Alma-0 that supports declarative programming. In this paper we illustrate the hybrid programming style of Alma-0 by means of various examples that complement those presented in (Apt et al, TOPLAS 1998). The presented Alma-0 programs illustrate the versatility of the language and show that ``don't know'' nondeterminism can be naturally combined with assignment.

With updated references with respect to the published version

Frontiers of Combining Systems 2, Research Studies Press Ltd, D. M. Gabbay and M. de Rijke (editors), pages 1-16, 1999

cs.LO

Constraint Programming viewed as Rule-based Programming

http://arxiv.org/abs/cs/0003076v2

http://arxiv.org/abs/cs/0003076v2

http://arxiv.org/pdf/cs/0003076v2

2000-03-24

2001-05-23

We study here a natural situation when constraint programming can be entirely reduced to rule-based programming. To this end we explain first how one can compute on constraint satisfaction problems using rules represented by simple first-order formulas. Then we consider constraint satisfaction problems that are based on predefined, explicitly given constraints. To solve them we first derive rules from these explicitly given constraints and limit the computation process to a repeated application of these rules, combined with labeling.We consider here two types of rules. The first type, that we call equality rules, leads to a new notion of local consistency, called {\em rule consistency} that turns out to be weaker than arc consistency for constraints of arbitrary arity (called hyper-arc consistency in \cite{MS98b}). For Boolean constraints rule consistency coincides with the closure under the well-known propagation rules for Boolean constraints. The second type of rules, that we call membership rules, yields a rule-based characterization of arc consistency. To show feasibility of this rule-based approach to constraint programming we show how both types of rules can be automatically generated, as {\tt CHR} rules of \cite{fruhwirth-constraint-95}. This yields an implementation of this approach to programming by means of constraint logic programming. We illustrate the usefulness of this approach to constraint programming by discussing various examples, including Boolean constraints, two typical examples of many valued logics, constraints dealing with Waltz's language for describing polyhedral scenes, and Allen's qualitative approach to temporal logic.

39 pages. To appear in Theory and Practice of Logic Programming Journal

cs.AI

The (Lazy) Functional Side of Logic Programming

http://arxiv.org/abs/cs/0003070v1

http://arxiv.org/abs/cs/0003070v1

http://arxiv.org/pdf/cs/0003070v1

2000-03-20

2000-03-20

The possibility of translating logic programs into functional ones has long been a subject of investigation. Common to the many approaches is that the original logic program, in order to be translated, needs to be well-moded and this has led to the common understanding that these programs can be considered to be the ``functional part'' of logic programs. As a consequence of this it has become widely accepted that ``complex'' logical variables, the possibility of a dynamic selection rule, and general properties of non-well-moded programs are exclusive features of logic programs. This is not quite true, as some of these features are naturally found in lazy functional languages. We readdress the old question of what features are exclusive to the logic programming paradigm by defining a simple translation applicable to a wider range of logic programs, and demonstrate that the current circumscription is unreasonably restrictive.

23 pages

cs.PL

A Polyvariant Binding-Time Analysis for Off-line Partial Deduction

http://arxiv.org/abs/cs/0003068v1

http://arxiv.org/abs/cs/0003068v1

http://arxiv.org/pdf/cs/0003068v1

2000-03-17

2000-03-17

We study the notion of binding-time analysis for logic programs. We formalise the unfolding aspect of an on-line partial deduction system as a Prolog program. Using abstract interpretation, we collect information about the run-time behaviour of the program. We use this information to make the control decisions about the unfolding at analysis time and to turn the on-line system into an off-line system. We report on some initial experiments.

19 pages (including appendix) Paper (without appendix) appeared in Programming Languages and Systems, Proceedings of the European Symposium on Programming (ESOP'98), Part of ETAPS'98 (Chris Hankin, eds.), LNCS, vol. 1381, 1998, pp. 27-41

cs.PL

Reasoning with Higher-Order Abstract Syntax in a Logical Framework

http://arxiv.org/abs/cs/0003062v2

http://arxiv.org/abs/cs/0003062v2

http://arxiv.org/pdf/cs/0003062v2

2000-03-14

2001-01-15

Logical frameworks based on intuitionistic or linear logics with higher-type quantification have been successfully used to give high-level, modular, and formal specifications of many important judgments in the area of programming languages and inference systems. Given such specifications, it is natural to consider proving properties about the specified systems in the framework: for example, given the specification of evaluation for a functional programming language, prove that the language is deterministic or that evaluation preserves types. One challenge in developing a framework for such reasoning is that higher-order abstract syntax (HOAS), an elegant and declarative treatment of object-level abstraction and substitution, is difficult to treat in proofs involving induction. In this paper, we present a meta-logic that can be used to reason about judgments coded using HOAS; this meta-logic is an extension of a simple intuitionistic logic that admits higher-order quantification over simply typed lambda-terms (key ingredients for HOAS) as well as induction and a notion of definition. We explore the difficulties of formal meta-theoretic analysis of HOAS encodings by considering encodings of intuitionistic and linear logics, and formally derive the admissibility of cut for important subsets of these logics. We then propose an approach to avoid the apparent tradeoff between the benefits of higher-order abstract syntax and the ability to analyze the resulting encodings. We illustrate this approach through examples involving the simple functional and imperative programming languages PCF and PCF:=. We formally derive such properties as unicity of typing, subject reduction, determinacy of evaluation, and the equivalence of transition semantics and natural semantics presentations of evaluation.

56 pages, 21 tables; revised in light of reviewer comments; to appear in ACM Transactions on Computational Logic

cs.LO

TSIA: A Dataflow Model

http://arxiv.org/abs/cs/0003010v1

http://arxiv.org/abs/cs/0003010v1

http://arxiv.org/pdf/cs/0003010v1

2000-03-06

2000-03-06

The Task System and Item Architecture (TSIA) is a model for transparent application execution. In many real-world projects, a TSIA provides a simple application with a transparent reliable, distributed, heterogeneous, adaptive, dynamic, real-time, parallel, secure or other execution. TSIA is suitable for many applications, not just for the simple applications served to date. This presentation shows that TSIA is a dataflow model - a long-standing model for transparent parallel execution. The advances to the dataflow model include a simple semantics, as well as support for input/output, for modifiable items and for other such effects.

cs.PL

SLT-Resolution for the Well-Founded Semantics

http://arxiv.org/abs/cs/0002016v3

http://arxiv.org/abs/cs/0002016v3

http://arxiv.org/pdf/cs/0002016v3

2000-02-27

2001-03-02

Global SLS-resolution and SLG-resolution are two representative mechanisms for top-down evaluation of the well-founded semantics of general logic programs. Global SLS-resolution is linear for query evaluation but suffers from infinite loops and redundant computations. In contrast, SLG-resolution resolves infinite loops and redundant computations by means of tabling, but it is not linear. The principal disadvantage of a non-linear approach is that it cannot be implemented using a simple, efficient stack-based memory structure nor can it be easily extended to handle some strictly sequential operators such as cuts in Prolog. In this paper, we present a linear tabling method, called SLT-resolution, for top-down evaluation of the well-founded semantics. SLT-resolution is a substantial extension of SLDNF-resolution with tabling. Its main features include: (1) It resolves infinite loops and redundant computations while preserving the linearity. (2) It is terminating, and sound and complete w.r.t. the well-founded semantics for programs with the bounded-term-size property with non-floundering queries. Its time complexity is comparable with SLG-resolution and polynomial for function-free logic programs. (3) Because of its linearity for query evaluation, SLT-resolution bridges the gap between the well-founded semantics and standard Prolog implementation techniques. It can be implemented by an extension to any existing Prolog abstract machines such as WAM or ATOAM.

Slight modification

Journal of Automated Reasoning 28(1):53-97, 2002

cs.AI

Fractal Symbolic Analysis

http://arxiv.org/abs/cs/0001009v1

http://arxiv.org/abs/cs/0001009v1

http://arxiv.org/pdf/cs/0001009v1

2000-01-12

2000-01-12

Restructuring compilers use dependence analysis to prove that the meaning of a program is not changed by a transformation. A well-known limitation of dependence analysis is that it examines only the memory locations read and written by a statement, and does not assume any particular interpretation for the operations in that statement. Exploiting the semantics of these operations enables a wider set of transformations to be used, and is critical for optimizing important codes such as LU factorization with pivoting. Symbolic execution of programs enables the exploitation of such semantic properties, but it is intractable for all but the simplest programs. In this paper, we propose a new form of symbolic analysis for use in restructuring compilers. Fractal symbolic analysis compares a program and its transformed version by repeatedly simplifying these programs until symbolic analysis becomes tractable, ensuring that equality of simplified programs is sufficient to guarantee equality of the original programs. We present a prototype implementation of fractal symbolic analysis, and show how it can be used to optimize the cache performance of LU factorization with pivoting.

13 pages, 19 figures

cs.PL

Why C++ is not very fit for GUI programming

http://arxiv.org/abs/cs/0001003v1

http://arxiv.org/abs/cs/0001003v1

http://arxiv.org/pdf/cs/0001003v1

2000-01-06

2000-01-06

With no intent of starting a holy war, this paper lists several annoying C++ birthmarks that the author has come across developing GUI class libraries. C++'s view of classes, instances and hierarchies appears tantalizingly close to GUI concepts of controls, widgets, window classes and subwindows. OO models of C++ and of a window system are however different. C++ was designed to be a "static" language with a lexical name scoping, static type checking and hierarchies defined at compile time. Screen objects on the other hand are inherently dynamic; they usually live well beyond the procedure/block that created them; the hierarchy of widgets is defined to a large extent by layout, visibility and event flow. Many GUI fundamentals such as dynamic and geometric hierarchies of windows and controls, broadcasting and percolation of events are not supported directly by C++ syntax or execution semantics (or supported as "exceptions" -- pun intended). Therefore these features have to be emulated in C++ GUI code. This leads to duplication of a graphical toolkit or a window manager functionality, code bloat, engaging in unsafe practices and forgoing of many strong C++ features (like scoping rules and compile-time type checking). This paper enumerates a few major C++/GUI sores and illustrates them on simple examples.

Previous version of this paper appeared in Proc. MacHack'95

cs.PL

Semantics of Programming Languages: A Tool-Oriented Approach

http://arxiv.org/abs/cs/9911001v2

http://arxiv.org/abs/cs/9911001v2

http://arxiv.org/pdf/cs/9911001v2

1999-11-04

1999-11-26

By paying more attention to semantics-based tool generation, programming language semantics can significantly increase its impact. Ultimately, this may lead to ``Language Design Assistants'' incorporating substantial amounts of semantic knowledge.

12 pages, 2 figures. Submitted to ACM SIGPLAN Notices

ACM SIGPLAN Notices V. 35(3) March 2000 pp. 39-48

cs.PL

Automatic Generation of Constraint Propagation Algorithms for Small Finite Domains

http://arxiv.org/abs/cs/9909010v1

http://arxiv.org/abs/cs/9909010v1

http://arxiv.org/pdf/cs/9909010v1

1999-09-08

1999-09-08

We study here constraint satisfaction problems that are based on predefined, explicitly given finite constraints. To solve them we propose a notion of rule consistency that can be expressed in terms of rules derived from the explicit representation of the initial constraints. This notion of local consistency is weaker than arc consistency for constraints of arbitrary arity but coincides with it when all domains are unary or binary. For Boolean constraints rule consistency coincides with the closure under the well-known propagation rules for Boolean constraints. By generalizing the format of the rules we obtain a characterization of arc consistency in terms of so-called inclusion rules. The advantage of rule consistency and this rule based characterization of the arc consistency is that the algorithms that enforce both notions can be automatically generated, as CHR rules. So these algorithms could be integrated into constraint logic programming systems such as Eclipse. We illustrate the usefulness of this approach to constraint propagation by discussing the implementations of both algorithms and their use on various examples, including Boolean constraints, three valued logic of Kleene, constraints dealing with Waltz's language for describing polyhedreal scenes, and Allen's qualitative approach to temporal logic.

15 pages. To appear in the Proc. 5th International Conference on Principles and Practice of Constraint Programming

cs.AI

The Rough Guide to Constraint Propagation

http://arxiv.org/abs/cs/9909009v1

http://arxiv.org/abs/cs/9909009v1

http://arxiv.org/pdf/cs/9909009v1

1999-09-08

1999-09-08

We provide here a simple, yet very general framework that allows us to explain several constraint propagation algorithms in a systematic way. In particular, using the notions commutativity and semi-commutativity, we show how the well-known AC-3, PC-2, DAC and DPC algorithms are instances of a single generic algorithm. The work reported here extends and simplifies that of Apt, cs.AI/9811024.

23 pages. To appear in the Proc. 5th International Conference on Principles and Practice of Constraint Programming as an invited talk

cs.AI

After Compilers and Operating Systems : The Third Advance in Application Support

http://arxiv.org/abs/cs/9908002v1

http://arxiv.org/abs/cs/9908002v1

http://arxiv.org/pdf/cs/9908002v1

1999-08-03

1999-08-03

After compilers and operating systems, TSIAs are the third advance in application support. A compiler supports a high level application definition in a programming language. An operating system supports a high level interface to the resources used by an application execution. A Task System and Item Architecture (TSIA) provides an application with a transparent reliable, distributed, heterogeneous, adaptive, dynamic, real-time, interactive, parallel, secure or other execution. In addition to supporting the application execution, a TSIA also supports the application definition. This run-time support for the definition is complementary to the compile-time support of a compiler. For example, this allows a language similar to Fortran or C to deliver features promised by functional computing. While many TSIAs exist, they previously have not been recognized as such and have served only a particular type of application. Existing TSIAs and other projects demonstrate that TSIAs are feasible for most applications. As the next paradigm for application support, the TSIA simplifies and unifies existing computing practice and research. By solving many outstanding problems, the TSIA opens many, many new opportunities for computing.

20 pages including 13 figures of diagrams and code examples. Based on invited seminars held in May-July 1999 at IBM, Caltech and elsewhere. For further information see http://www.tsia.org

cs.PL

The Alma Project, or How First-Order Logic Can Help Us in Imperative Programming

http://arxiv.org/abs/cs/9907027v1

http://arxiv.org/abs/cs/9907027v1

http://arxiv.org/pdf/cs/9907027v1

1999-07-19

1999-07-19

The aim of the Alma project is the design of a strongly typed constraint programming language that combines the advantages of logic and imperative programming. The first stage of the project was the design and implementation of Alma-0, a small programming language that provides a support for declarative programming within the imperative programming framework. It is obtained by extending a subset of Modula-2 by a small number of features inspired by the logic programming paradigm. In this paper we discuss the rationale for the design of Alma-0, the benefits of the resulting hybrid programming framework, and the current work on adding constraint processing capabilities to the language. In particular, we discuss the role of the logical and customary variables, the interaction between the constraint store and the program, and the need for lists.

25 pages

cs.LO

Combining Inclusion Polymorphism and Parametric Polymorphism

http://arxiv.org/abs/cs/9906013v1

http://arxiv.org/abs/cs/9906013v1

http://arxiv.org/pdf/cs/9906013v1

1999-06-14

1999-06-14

We show that the question whether a term is typable is decidable for type systems combining inclusion polymorphism with parametric polymorphism provided the type constructors are at most unary. To prove this result we first reduce the typability problem to the problem of solving a system of type inequations. The result is then obtained by showing that the solvability of the resulting system of type inequations is decidable.

14 pages

cs.LO

DRAFT : Task System and Item Architecture (TSIA)

http://arxiv.org/abs/cs/9905002v1

http://arxiv.org/abs/cs/9905002v1

http://arxiv.org/pdf/cs/9905002v1

1999-05-05

1999-05-05

During its execution, a task is independent of all other tasks. For an application which executes in terms of tasks, the application definition can be free of the details of the execution. Many projects have demonstrated that a task system (TS) can provide such an application with a parallel, distributed, heterogeneous, adaptive, dynamic, real-time, interactive, reliable, secure or other execution. A task consists of items and thus the application is defined in terms of items. An item architecture (IA) can support arrays, routines and other structures of items, thus allowing for a structured application definition. Taking properties from many projects, the support can extend through to currying, application defined types, conditional items, streams and other definition elements. A task system and item architecture (TSIA) thus promises unprecedented levels of support for application execution and definition.

vii+244 pages, including 126 figures of diagrams and code examples. Submitted to Springer Verlag. For further information see http://www.tsia.org

cs.PL

A Machine-Independent Debugger--Revisited

http://arxiv.org/abs/cs/9904017v1

http://arxiv.org/abs/cs/9904017v1

http://arxiv.org/pdf/cs/9904017v1

1999-04-23

1999-04-23

Most debuggers are notoriously machine-dependent, but some recent research prototypes achieve varying degrees of machine-independence with novel designs. Cdb, a simple source-level debugger for C, is completely independent of its target architecture. This independence is achieved by embedding symbol tables and debugging code in the target program, which costs both time and space. This paper describes a revised design and implementation of cdb that reduces the space cost by nearly one-half and the time cost by 13% by storing symbol tables in external files. A symbol table is defined by a 31-line grammar in the Abstract Syntax Description Language (ASDL). ASDL is a domain-specific language for specifying tree data structures. The ASDL tools accept an ASDL grammar and generate code to construct, read, and write these data structures. Using ASDL automates implementing parts of the debugger, and the grammar documents the symbol table concisely. Using ASDL also suggested simplifications to the interface between the debugger and the target program. Perhaps most important, ASDL emphasizes that symbol tables are data structures, not file formats. Many of the pitfalls of working with low-level file formats can be avoided by focusing instead on high-level data structures and automating the implementation details.

12 pages; 6 figures; 3 tables

Software--Practice & Experience, vol. 29, no. 10, 849-862, Aug. 1999

cs.PL

WebScript -- A Scripting Language for the Web

http://arxiv.org/abs/cs/9904011v1

http://arxiv.org/abs/cs/9904011v1

http://arxiv.org/pdf/cs/9904011v1

1999-04-21

1999-04-21

WebScript is a scripting language for processing Web documents. Designed as an extension to Jacl, the Java implementation of Tcl, WebScript allows programmers to manipulate HTML in the same way as Tcl manipulates text strings and GUI elements. This leads to a completely new way of writing the next generation of Web applications. This paper presents the motivation behind the design and implementation of WebScript, an overview of its major features, as well as some demonstrations of its power.

19 pages, 11 figures

cs.NI

Perpetual Adaptation of Software to Hardware: An Extensible Architecture for Providing Code Optimization as a Central System Service

http://arxiv.org/abs/cs/9903014v1

http://arxiv.org/abs/cs/9903014v1

http://arxiv.org/pdf/cs/9903014v1

1999-03-22

1999-03-22

We present an open architecture for just-in-time code generation and dynamic code optimization that is flexible, customizable, and extensible. While previous research has primarily investigated functional aspects of such a system, architectural aspects have so far remained unexplored. In this paper, we argue that these properties are important to generate optimal code for a variety of hardware architectures and different processor generations within processor families. These properties are also important to make system-level code generation useful in practice.

22 pages

cs.OS

Universal Object Oriented Languages and Computer Algebra

http://arxiv.org/abs/cs/9901007v1

http://arxiv.org/abs/cs/9901007v1

http://arxiv.org/pdf/cs/9901007v1

1999-01-15

1999-01-15

The universal object oriented languages made programming more simple and efficient. In the article is considered possibilities of using similar methods in computer algebra. A clear and powerful universal language is useful if particular problem was not implemented in standard software packages like REDUCE, MATHEMATICA, etc. and if the using of internal programming languages of the packages looks not very efficient. Functional languages like LISP had some advantages and traditions for algebraic and symbolic manipulations. Functional and object oriented programming are not incompatible ones. An extension of the model of an object for manipulation with pure functions and algebraic expressions is considered.

5 pages LaTeX, (3 pages extended abstract of talk at International Conference: Computer Algebra in Scientific Computing, CASC'98, 20-24 Apr 1998, St.-Petersburg, Russia; + 2 pages of comments to 3 slides included as 3 separate ps files)

Computer Algebra in Scientific Computing. Extended abstracts of the International Conference CASC-98, ed by N.N.Vasiliev -- St.-Petersburg, 1998, pages 130 -- 132

cs.PL

Object Oriented and Functional Programming for Symbolic Manipulation

http://arxiv.org/abs/cs/9901006v1

http://arxiv.org/abs/cs/9901006v1

http://arxiv.org/pdf/cs/9901006v1

1999-01-13

1999-01-13

The advantages of mixed approach with using different kinds of programming techniques for symbolic manipulation are discussed. The main purpose of approach offered is merge the methods of object oriented programming that convenient for presentation data and algorithms for user with advantages of functional languages for data manipulation, internal presentation, and portability of software.

6 pages, LaTeX, poster presentation at 5th International Workshop on New Computing Techniques in Physics Research (AIHENP'96), http://lapphp0.in2p3.fr/aihep/aihep96/abstracts/sm.html , EPFL Lausanne, (Switzerland), 2 - 6 Sep 1996; corrected due to referee suggestions (Nov 96), adjusted to LaTeX2e article class (Jan 99)

cs.SC

Automatic Hardware Synthesis for a Hybrid Reconfigurable CPU Featuring Philips CPLDs

http://arxiv.org/abs/cs/9811021v1

http://arxiv.org/abs/cs/9811021v1

http://arxiv.org/pdf/cs/9811021v1

1998-11-12

1998-11-12

A high-level architecture of a Hybrid Reconfigurable CPU, based on a Philips-supported core processor, is introduced. It features the Philips XPLA2 CPLD as a reconfigurable functional unit. A compilation chain is presented, in which automatic implementation of time-critical program segments in custom hardware is performed. The entire process is transparent from the programmer's point of view. The hardware synthesis module of the chain, which translates segments of assembly code into a hardware netlist, is discussed in details. Application examples are also presented.

6 pages, 7 figures, PACT '98 Workshop on Reconfigurable Computing

cs.PL

An Emptiness Algorithm for Regular Types with Set Operators

http://arxiv.org/abs/cs/9811015v1

http://arxiv.org/abs/cs/9811015v1

http://arxiv.org/pdf/cs/9811015v1

1998-11-11

1998-11-11

An algorithm to decide the emptiness of a regular type expression with set operators given a set of parameterised type definitions is presented. The algorithm can also be used to decide the equivalence of two regular type expressions and the inclusion of one regular type expression in another. The algorithm strictly generalises previous work in that tuple distributivity is not assumed and set operators are permitted in type expressions.

22 pages

cs.LO

Deriving Abstract Semantics for Forward Analysis of Normal Logic Programs

http://arxiv.org/abs/cs/9811012v1

http://arxiv.org/abs/cs/9811012v1

http://arxiv.org/pdf/cs/9811012v1

1998-11-06

1998-11-06

The problem of forward abstract interpretation of {\em normal} logic programs has not been formally addressed in the literature although negation as failure is dealt with through the built-in predicate ! in the way it is implemented in Prolog. This paper proposes a solution to this problem by deriving two generic fixed-point abstract semantics $F^b and $F^\diamond for forward abstract interpretation of {\em normal} logic programs. $F^b$ is intended for inferring data descriptions for edges in the program graph where an edge denotes the possibility that the control of execution transfers from its source program point to its destination program point. $F^\diamond$ is derived from $F^b$ and is intended for inferring data descriptions for textual program points.

39 pages

cs.PL

A Polymorphic Groundness Analysis of Logic Programs

http://arxiv.org/abs/cs/9811001v1

http://arxiv.org/abs/cs/9811001v1

http://arxiv.org/pdf/cs/9811001v1

1998-10-31

1998-10-31

A polymorphic analysis is an analysis whose input and output contain parameters which serve as placeholders for information that is unknown before analysis but provided after analysis. In this paper, we present a polymorphic groundness analysis that infers parameterised groundness descriptions of the variables of interest at a program point. The polymorphic groundness analysis is designed by replacing two primitive operators used in a monomorphic groundness analysis and is shown to be as precise as the monomorphic groundness analysis for any possible values for mode parameters. Experimental results of a prototype implementation of the polymorphic groundness analysis are given.

30 pages

cs.PL

Linguistic Reflection in Java

http://arxiv.org/abs/cs/9810027v1

http://arxiv.org/abs/cs/9810027v1

http://arxiv.org/pdf/cs/9810027v1

1998-10-29

1998-10-29

Reflective systems allow their own structures to be altered from within. Here we are concerned with a style of reflection, called linguistic reflection, which is the ability of a running program to generate new program fragments and to integrate these into its own execution. In particular we describe how this kind of reflection may be provided in the compiler-based, strongly typed object-oriented programming language Java. The advantages of the programming technique include attaining high levels of genericity and accommodating system evolution. These advantages are illustrated by an example taken from persistent programming which shows how linguistic reflection allows functionality (program code) to be generated on demand (Just-In-Time) from a generic specification and integrated into the evolving running program. The technique is evaluated against alternative implementation approaches with respect to efficiency, safety and ease of use.

25 pages. Source code for examples at http://www-ppg.dcs.st-and.ac.uk/Java/ReflectionExample/ Dynamic compilation package at http://www-ppg.dcs.st-and.ac.uk/Java/DynamicCompilation/

Software - Practice & Experience 28, 10 (1998) pp 1045-1077

cs.PL

A Proof Theoretic View of Constraint Programming

http://arxiv.org/abs/cs/9810018v1

http://arxiv.org/abs/cs/9810018v1

http://arxiv.org/pdf/cs/9810018v1

1998-10-20

1998-10-20

We provide here a proof theoretic account of constraint programming that attempts to capture the essential ingredients of this programming style. We exemplify it by presenting proof rules for linear constraints over interval domains, and illustrate their use by analyzing the constraint propagation process for the {\tt SEND + MORE = MONEY} puzzle. We also show how this approach allows one to build new constraint solvers.

25 pages

Fundamenta Informaticae 34(1998), pp. 295-321

cs.AI

Early Experience with ASDL in lcc

http://arxiv.org/abs/cs/9810013v1

http://arxiv.org/abs/cs/9810013v1

http://arxiv.org/pdf/cs/9810013v1

1998-10-13

1998-10-13

The Abstract Syntax Description Language (ASDL) is a language for specifying the tree data structures often found in compiler intermediate representations. The ASDL generator reads an ASDL specification and generates code to construct, read, and write instances of the trees specified. Using ASDL permits a compiler to be decomposed into semi-independent components that communicate by reading and writing trees. Each component can be written in a different language, because the ASDL generator can emit code in several languages, and the files written by ASDL-generated code are machine- and language-independent. ASDL is part of the National Compiler Infrastructure project, which seeks to reduce dramatically the overhead of computer systems research by making it much easier to build high-quality compilers. This paper describes dividing lcc, a widely used retargetable C compiler, into two components that communicate via trees defined in ASDL. As the first use of ASDL in a `real' compiler, this experience reveals much about the effort required to retrofit an existing compiler to use ASDL, the overheads involved, and the strengths and weaknesses of ASDL itself and, secondarily, of lcc.

16 pages, 12 figures

Software--Practice & Experience, vol. 29, no. 5, 417-435, Apr. 1999

cs.PL

C++ Templates as Partial Evaluation

http://arxiv.org/abs/cs/9810010v2

http://arxiv.org/abs/cs/9810010v2

http://arxiv.org/pdf/cs/9810010v2

1998-10-09

1998-11-02

This paper explores the relationship between C++ templates and partial evaluation. Templates were designed to support generic programming, but unintentionally provided the ability to perform compile-time computations and code generation. These features are completely accidental, and as a result their syntax is awkward. By recasting these features in terms of partial evaluation, a much simpler syntax can be achieved. C++ may be regarded as a two-level language in which types are first-class values. Template instantiation resembles an offline partial evaluator. This paper describes preliminary work toward a single mechanism based on Partial Evaluation which unifies generic programming, compile-time computation and code generation. The language Catat is introduced to illustrate these ideas.

13 pages

cs.PL

Active Libraries: Rethinking the roles of compilers and libraries

http://arxiv.org/abs/math/9810022v1

http://arxiv.org/abs/math/9810022v1

http://arxiv.org/pdf/math/9810022v1

1998-10-05

1998-10-05

We describe Active Libraries, which take an active role in compilation. Unlike traditional libraries which are passive collections of functions and objects, Active Libraries may generate components, specialize algorithms, optimize code, configure and tune themselves for a target machine, and describe themselves to tools (such as profilers and debuggers) in an intelligible way. Several such libraries are described, as are implementation technologies.

16 pages, 1998 SIAM Workshop on Object Oriented Methods for Inter-operable Scientific and Engineering Computing

math.NA

On Dart-Zobel Algorithm for Testing Regular Type Inclusion

http://arxiv.org/abs/cs/9810001v1

http://arxiv.org/abs/cs/9810001v1

http://arxiv.org/pdf/cs/9810001v1

1998-10-01

1998-10-01

This paper answers open questions about the correctness and the completeness of Dart-Zobel algorithm for testing the inclusion relation between two regular types. We show that the algorithm is incorrect for regular types. We also prove that the algorithm is complete for regular types as well as correct for tuple distributive regular types. Also presented is a simplified version of Dart-Zobel algorithm for tuple distributive regular types.

16 pages

cs.LO

Scoping Constructs in Logic Programming: Implementation Problems and their Solution

http://arxiv.org/abs/cs/9809016v1

http://arxiv.org/abs/cs/9809016v1

http://arxiv.org/pdf/cs/9809016v1

1998-09-10

1998-09-10

The inclusion of universal quantification and a form of implication in goals in logic programming is considered. These additions provide a logical basis for scoping but they also raise new implementation problems. When universal and existential quantifiers are permitted to appear in mixed order in goals, the devices of logic variables and unification that are employed in solving existential goals must be modified to ensure that constraints arising out of the order of quantification are respected. Suitable modifications that are based on attaching numerical tags to constants and variables and on using these tags in unification are described. The resulting devices are amenable to an efficient implementation and can, in fact, be assimilated easily into the usual machinery of the Warren Abstract Machine (WAM). The provision of implications in goals results in the possibility of program clauses being added to the program for the purpose of solving specific subgoals. A naive scheme based on asserting and retracting program clauses does not suffice for implementing such additions for two reasons. First, it is necessary to also support the resurrection of an earlier existing program in the face of backtracking. Second, the possibility for implication goals to be surrounded by quantifiers requires a consideration of the parameterization of program clauses by bindings for their free variables. Devices for supporting these additional requirements are described as also is the integration of these devices into the WAM. Further extensions to the machine are outlined for handling higher-order additions to the language. The ideas presented here are relevant to the implementation of the higher-order logic programming language lambda Prolog.

46 pages

Journal of Logic Programming, 25(2)-119:161, 1995

cs.PL

Comparing the expressive power of the Synchronous and the Asynchronous pi-calculus

http://arxiv.org/abs/cs/9809008v1

http://arxiv.org/abs/cs/9809008v1

http://arxiv.org/pdf/cs/9809008v1

1998-09-02

1998-09-02

The Asynchronous pi-calculus, as recently proposed by Boudol and, independently, by Honda and Tokoro, is a subset of the pi-calculus which contains no explicit operators for choice and output-prefixing. The communication mechanism of this calculus, however, is powerful enough to simulate output-prefixing, as shown by Boudol, and input-guarded choice, as shown recently by Nestmann and Pierce. A natural question arises, then, whether or not it is possible to embed in it the full pi-calculus. We show that this is not possible, i.e. there does not exist any uniform, parallel-preserving, translation from the pi-calculus into the asynchronous pi-calculus, up to any ``reasonable'' notion of equivalence. This result is based on the incapablity of the asynchronous pi-calculus of breaking certain symmetries possibly present in the initial communication graph. By similar arguments, we prove a separation result between the pi-calculus and CCS.

10 pages. Proc. of the POPL'97 symposium

Proc. of the 24th ACM Symposium on Principles of Programming Languages (POPL), pages 256--265, ACM, 1997

cs.PL

Mini-indexes for literate programs

http://arxiv.org/abs/cs/9401102v1

http://arxiv.org/abs/cs/9401102v1

http://arxiv.org/pdf/cs/9401102v1

1994-01-01

1994-01-01

This paper describes how to implement a documentation technique that helps readers to understand large programs or collections of programs, by providing local indexes to all identifiers that are visible on every two-page spread. A detailed example is given for a program that finds all Hamiltonian circuits in an undirected graph.

Software -- Concepts and Tools 15 (1994), 2--11

cs.PL