4,245 research outputs found
DEBS Grand Challenge: Glasgow Automata Illustrated
The challenge is solved using Glasgow automata, concise complex event processing engines executable in the context of a topic-based publish/subscribe cache of event streams and relations. The imperative programming style of the Glasgow Automaton Programming Language (GAPL) enables multiple, efficient realisations of the two challenge queries
Compensations in an imperative programming language
Numerous mechanisms are used to deal with failure of sys- tems or processes, one of which is that of compensating ac- tions. A compensation can be seen as a program which somehow cancels out the effects of another — and by or- ganising code in such a way so as to associate each program with its compensation, enables implicit recovery to a sane state if part of a computation somehow fails. In this paper we present an imperative programming language natively supporting the notion of compensations, thus enabling the programmer to program using a notion of compensations at the source level of the system under development.peer-reviewe
A generic imperative language for polynomial time
The ramification method in Implicit Computational Complexity has been
associated with functional programming, but adapting it to generic imperative
programming is highly desirable, given the wider algorithmic applicability of
imperative programming. We introduce a new approach to ramification which,
among other benefits, adapts readily to fully general imperative programming.
The novelty is in ramifying finite second-order objects, namely finite
structures, rather than ramifying elements of free algebras. In so doing we
bridge between Implicit Complexity's type theoretic characterizations of
feasibility, and the data-flow approach of Static Analysis.Comment: 18 pages, submitted to a conferenc
Adding imperative programming to the pattern calculus
University of Technology, Sydney. Dept. of Software Engineering.By focusing on data and flow control, imperative languages provide a finely grained and efficient mechanism for directly manipulating state and memory. By focusing on functions, polymorphism increases the modularity and reusability of programs. The pattern calculus gives a new account of polymorphism over arbitrary datatypes which has been used as the foundation for building the functional language FISh2. The power of the new polymorphism is not limited to a functional setting and it can be extended into an imperative setting. The main contribution of this thesis is to expand the pattern calculus with imperative features and implement this within a version of FISh2.
Two approaches are developed in expanding the calculus to imperative programming based on two setting: functional and imperative. Based on a functional setting, updatable locations are given separate location types; while based on an imperative setting, locations and their values share the same types. In both approaches, structured locations can be defined in the same way the calculus defines structured data. Hence, generic functions on locations can be defined by pattern-matching on (location) constructors. In that way, the power of the combination exceeds that of the boundary of functional or imperative alone. In particular, with the generic assignment function, we have a new approach on memory management which performs inplace update whenever it is reasonable to do so.
Similar ideas could be used to extend the power of parametric polymorphism to parallel programming. To illustrate the approach, a key problem is addressed in detail, namely, distributing a data structure over a network of processors
Declaratively solving Google Code Jam problems with Picat
In this paper we present several examples of solving algorithmic problems
from the Google Code Jam programming contest with Picat programming language
using declarative techniques: constraint logic programming and tabled logic
programming. In some cases the use of Picat simplifies the implementation
compared to conventional imperative programming languages, while in others it
allows to directly convert the problem statement into an efficiently solvable
declarative problem specification without inventing an imperative algorithm
- …