84,806 research outputs found
Relaxed Operational Semantics of Concurrent Programming Languages
We propose a novel, operational framework to formally describe the semantics
of concurrent programs running within the context of a relaxed memory model.
Our framework features a "temporary store" where the memory operations issued
by the threads are recorded, in program order. A memory model then specifies
the conditions under which a pending operation from this sequence is allowed to
be globally performed, possibly out of order. The memory model also involves a
"write grain," accounting for architectures where a thread may read a write
that is not yet globally visible. Our formal model is supported by a software
simulator, allowing us to run litmus tests in our semantics.Comment: In Proceedings EXPRESS/SOS 2012, arXiv:1208.244
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
A semantics and implementation of a causal logic programming language
The increasingly widespread availability of multicore and manycore computers demands new programming languages that make parallel programming dramatically easier and less error prone. This paper describes a semantics for a new class of declarative programming languages that support massive amounts of implicit parallelism
Probabilistic Programming Concepts
A multitude of different probabilistic programming languages exists today,
all extending a traditional programming language with primitives to support
modeling of complex, structured probability distributions. Each of these
languages employs its own probabilistic primitives, and comes with a particular
syntax, semantics and inference procedure. This makes it hard to understand the
underlying programming concepts and appreciate the differences between the
different languages. To obtain a better understanding of probabilistic
programming, we identify a number of core programming concepts underlying the
primitives used by various probabilistic languages, discuss the execution
mechanisms that they require and use these to position state-of-the-art
probabilistic languages and their implementation. While doing so, we focus on
probabilistic extensions of logic programming languages such as Prolog, which
have been developed since more than 20 years
A categorical foundation for structured reversible flowchart languages: Soundness and adequacy
Structured reversible flowchart languages is a class of imperative reversible
programming languages allowing for a simple diagrammatic representation of
control flow built from a limited set of control flow structures. This class
includes the reversible programming language Janus (without recursion), as well
as more recently developed reversible programming languages such as R-CORE and
R-WHILE.
In the present paper, we develop a categorical foundation for this class of
languages based on inverse categories with joins. We generalize the notion of
extensivity of restriction categories to one that may be accommodated by
inverse categories, and use the resulting decisions to give a reversible
representation of predicates and assertions. This leads to a categorical
semantics for structured reversible flowcharts, which we show to be
computationally sound and adequate, as well as equationally fully abstract with
respect to the operational semantics under certain conditions
A comparative study of formalisms for programming language definition : a thesis presented in partial fulfilment of the requirements for the degree of Master of Science in Computer Science at Massey University
This study looks at a number of methods for defining the full syntax and semantics of computer programming languages. The syntax, especially the nature of context-dependent conditions in it, is first examined, then some extensions of context-free grammars are compared to see to what extent they can encompass the full context-conditions of typical programming languages. It is found that several syntax extensions are inadequate in this regard, and that the ability to calculate complicated functions and conditions, and to eventually delete the values of such functions, is needed. This ability may be obtained either by allowing unrestricted rules and meta-variables in the phrase-structure, or by associating mathematical functions either with individual production rules or with the whole context-free structure, to transform it into an 'abstract syntax'. Since the form of a definition of a programming language semantics depends critically on how one conceives "meaning", five main types of semantics are considered: these are called 'natural', 'prepositional', 'functional', and 'structural' semantics, as well as a semantics based on string rewriting rules. The five types are compared for their success in defining the semantics of computing languages, of the example Algol-like language ALEX in particular. Among other conclusions, it is found that the semantics of structures and computations on structures is the only type sufficiently comprehensive, precise, and readable
UN APPROCCIO FORMALE ALLA DESCRIZIONE DELLA SEMANTICA DEI LINGUAGGI DI PROGRAMMAZIONE
The creation of new programming languages, capable of fully deploying the new technological innovations and operating environments, requires more and more accurate and affordable analysis. In this study, a technique for the generation of formal models for the specification of the semantics of the programming languages is presented. Tools are used newer than the semantics of Kleene - such as the Scotts theory of the cathegories and mathematical theory of the computation, which are here outlined and motivated.
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
- ā¦