189,982 research outputs found
Action semantics in retrospect
This paper is a themed account of the action semantics project, which Peter Mosses has led since the 1980s. It explains his motivations for developing action semantics, the inspirations behind its design, and the foundations of action semantics based on unified algebras. It goes on to outline some applications of action semantics to describe real programming languages, and some efforts to implement programming languages using action semantics directed compiler generation. It concludes by outlining more recent developments and reflecting on the success of the action semantics project
Representing First-Order Causal Theories by Logic Programs
Nonmonotonic causal logic, introduced by Norman McCain and Hudson Turner,
became a basis for the semantics of several expressive action languages.
McCain's embedding of definite propositional causal theories into logic
programming paved the way to the use of answer set solvers for answering
queries about actions described in such languages. In this paper we extend this
embedding to nondefinite theories and to first-order causal logic.Comment: 29 pages. To appear in Theory and Practice of Logic Programming
(TPLP); Theory and Practice of Logic Programming, May, 201
Recommended from our members
A general theory of action languages
We present a general theory of action-based languages as a paradigm, for the description, of those computational
systems which include elements of concurrency and networking, and extend this approach
to describe dist.ributed systems and also t,o describe the interaction of a system, with an environment.
As part of this approach we introduce the Action Language as a common model for the class of nondeterministic
concurrent programming languages and define its intensional and interaction semantics
in terrors of continuous transformation of environment behavior. This semantics i.s specialized for
programs with stores, and extended to describe distributed computations
An Introduction to Action Semantics
Formal semantics is a topic of major importance in the study of programming languages. Its applications include documenting language design, establishing standards for implementations, reasoning about programs, and generating compilers. These notes introduce action semantics, a recently-developed framework for formal semantics. The primary aim of action semantics is to allow useful semantic descriptions of realistic programming languages
Handling Defeasibilities in Action Domains
Representing defeasibility is an important issue in common sense reasoning.
In reasoning about action and change, this issue becomes more difficult because
domain and action related defeasible information may conflict with general
inertia rules. Furthermore, different types of defeasible information may also
interfere with each other during the reasoning. In this paper, we develop a
prioritized logic programming approach to handle defeasibilities in reasoning
about action. In particular, we propose three action languages {\cal AT}^{0},
{\cal AT}^{1} and {\cal AT}^{2} which handle three types of defeasibilities in
action domains named defeasible constraints, defeasible observations and
actions with defeasible and abnormal effects respectively. Each language with a
higher superscript can be viewed as an extension of the language with a lower
superscript. These action languages inherit the simple syntax of {\cal A}
language but their semantics is developed in terms of transition systems where
transition functions are defined based on prioritized logic programs. By
illustrating various examples, we show that our approach eventually provides a
powerful mechanism to handle various defeasibilities in temporal prediction and
postdiction. We also investigate semantic properties of these three action
languages and characterize classes of action domains that present more
desirable solutions in reasoning about action within the underlying action
languages.Comment: 49 pages, 1 figure, to be appeared in journal Theory and Practice
Logic Programmin
Recommended from our members
GAEA Action Equations Paradigm
This technical report consists of two papers describing the GAEA action equations paradigm. Incremental Dynamic Semantics for Language-based Programming Environments explains why attribute grammars are not suitable for expressing dynamic semantics and presents action equations, an extension of attribute grammars suitable for specifying the static and the dynamic semantics of programming languages. It describes how action equations can be used to generate language-based programming environments that incrementally derive static and dynamic properties as the user modifies and debugs the program. Rapid Prototyping of Concurrent Programming Languages extends this technology to a concurrent framework. It describes an (unimplemented) system that generates a parallel interpreter for the language and provides runtime support for the synchronization primitives and other facilities in the language
Action languages: Dimensions, effects
Dimensions of action languages are discussed for communication between humans and machines, and the message handling capabilities of object oriented programming systems are examined. Design of action languages is seen to be very contextual. Economical and effective design will depend on features of situations, the tasks intended to be accomplished, and the nature of the devices themselves. Current object oriented systems turn out to have fairly simple and straightforward message handling facilities, which in themselves do little to buffer action or even in some cases to handle competing messages. Even so, it is possible to program a certain amount of discretion about how they react to messages. Such thoughtfulness and perhaps relative autonomy of program modules seems prerequisite to future systems to handle complex interactions in changing situations
Recommended from our members
Incremental Dynamic Semantics for Language-Based Programming Environments
Attribute grammars are a formal notation for expressing the static semantics of programming languages — those properties that can be derived from inspection of the program text. Attribute grammars have become popular as a mechanism for generating language-based programming environments that incrementally perform symbol resolution, type checking, code generation and derivation of other static semantic properties as the program is modified. However, attribute grammars are not suitable for expressing dynamic semantics — those properties that reflect the history of program execution and/or user interactions with the programming environment. This article presents action equations, an extension of attribute grammars suitable for specifying the static and the dynamic semantics of programming languages. It describes how action equations can be used to generate language-based programming environments that incrementally derive static and dynamic properties as the user modifies and debugs the program
- …