152,504 research outputs found
Transformations of CCP programs
We introduce a transformation system for concurrent constraint programming
(CCP). We define suitable applicability conditions for the transformations
which guarantee that the input/output CCP semantics is preserved also when
distinguishing deadlocked computations from successful ones and when
considering intermediate results of (possibly) non-terminating computations.
The system allows us to optimize CCP programs while preserving their intended
meaning: In addition to the usual benefits that one has for sequential
declarative languages, the transformation of concurrent programs can also lead
to the elimination of communication channels and of synchronization points, to
the transformation of non-deterministic computations into deterministic ones,
and to the crucial saving of computational space. Furthermore, since the
transformation system preserves the deadlock behavior of programs, it can be
used for proving deadlock freeness of a given program wrt a class of queries.
To this aim it is sometimes sufficient to apply our transformations and to
specialize the resulting program wrt the given queries in such a way that the
obtained program is trivially deadlock free.Comment: To appear in ACM TOPLA
Static Application-Level Race Detection in STM Haskell using Contracts
Writing concurrent programs is a hard task, even when using high-level
synchronization primitives such as transactional memories together with a
functional language with well-controlled side-effects such as Haskell, because
the interferences generated by the processes to each other can occur at
different levels and in a very subtle way. The problem occurs when a thread
leaves or exposes the shared data in an inconsistent state with respect to the
application logic or the real meaning of the data. In this paper, we propose to
associate contracts to transactions and we define a program transformation that
makes it possible to extend static contract checking in the context of STM
Haskell. As a result, we are able to check statically that each transaction of
a STM Haskell program handles the shared data in a such way that a given
consistency property, expressed in the form of a user-defined boolean function,
is preserved. This ensures that bad interference will not occur during the
execution of the concurrent program.Comment: In Proceedings PLACES 2013, arXiv:1312.2218. [email protected];
[email protected]
Compiling SHIM
Embedded systems demand concurrency for supporting simultaneous actions in their environment and parallel hardware. Although most concurrent programming formalisms are prone to races and non-determinism, some, such as our SHIM (software/hardware integration medium) language, avoid them by design. In particular, the behavior of SHIM programs is scheduling-independent, meaning the I/O behavior of a program is independent of scheduling policies, including the relative execution rates of concurrent processes. The SHIM project demonstrates how a scheduling-independent language simplifies the design, optimization, and verification of concurrent systems. Through examples and discussion, we describe the SHIM language and code generation techniques for both shared-memory and message-passing architectures, along with some verification algorithms
You Learn When You Teach: A Narrative Pedagogy for Faculty and Doctoral-Level Student Teaching Assistants
The purpose of this study was to understand the meaning of online co-teaching for PhD faculty and teaching assistants (TAs). Narrative pedagogy underpinned the inquiry, which was designed to advance the discourse on mentorship of PhD future faculty. A faculty member and TA authors kept concurrent weekly journals or after-the-fact written reflections. The authors analyzed data as a team using a five-phase interpretive phenomenological analysis process to interpret the meaning of co-teaching for faculty and TAs. Lines of inquiry, central concerns, exemplars, shared meanings, and paradigm cases supported the overall interpretation, “You Learn When You Teach.” Co-mentorship should be a requirement for nursing faculty preparation programs. Five strategies for ensuring success of PhD nursing students’ development as professional nurse scholars are recommended. Doctoral programs (e.g., PhD; DNP) would benefit from a unified approach to faculty preparation, guided by theories such as narrative pedagogy
Reverse Software Engineering of Concurrent Real Time Programs
This paper presents an algorithm for translating concurrent procedural language programs into nonprocedural, mathematical language programs, called specifications. The goal is to achieve reuse of old existing programs in developing new systems, through having them explained automatically and facilitating their modification.
Mathematical languages are widely believed to be superior to procedural languages. Unlike procedural languages, mathematical languages do not have side effects and are oblivious to computer concepts. Thus mathematical languages free the user of having to think like a computer when developing or modifying a program. Its mathematical semantics make proving software correctness easier and improves software reliability. The specification can then be used to generate automatically highly efficient procedural language programs for computer system.
The translation algorithm centers around the difference in the meaning of variables in procedural and mathematical languages. In a procedural language a variable may be assigned many values. In a mathematical language, however, a variable may be assigned only one value. The translation algorithm focuses on renaming variables in a procedural language program so that each variable is assigned only one value.
This paper also presents a methodology for proving specification correctness. The idea is based on generating scenarios that define values of variable for an applicable situation and using this to prove the specification satisfy a given requirement. This is contrasted with use of temporal logic for proving correctness of concurrent programs
Formalizing Determinacy of Concurrent Revisions
Concurrent revisions is a concurrency control model designed to guarantee
determinacy, meaning that the outcomes of programs are uniquely determined.
This paper describes an Isabelle/HOL formalization of the model's operational
semantics and proof of determinacy. We discuss and resolve subtle ambiguities
in the operational semantics and simplify the proof of determinacy. Although
our findings do not appear to correspond to bugs in implementations, the
formalization highlights some of the challenges involved in the design and
verification of concurrency control models.Comment: To appear in: Proceedings of the 9th ACM SIGPLAN International
Conference on Certified Programs and Proofs (CPP '20), January 20--21, 2020,
New Orleans, LA, USA. ACM, New York, NY, US
Unfolding in CHR
Program transformation is an appealing technique which allows to improve
run-time efficiency, space-consumption and more generally to optimize a given
program. Essentially it consists of a sequence of syntactic program
manipulations which preserves some kind of semantic equivalence. One of the
basic operations which is used by most program transformation systems is
unfolding which consists in the replacement of a procedure call by its
definition. While there is a large body of literature on transformation and
unfolding of sequential programs, very few papers have addressed this issue for
concurrent languages and, to the best of our knowledge, no other has considered
unfolding of CHR programs.
This paper defines a correct unfolding system for CHR programs. We define an
unfolding rule, show its correctness and discuss some conditions which can be
used to delete an unfolded rule while preserving the program meaning. We prove
that confluence and termination properties are preserved by the above
transformations
Logic-Based Specification Languages for Intelligent Software Agents
The research field of Agent-Oriented Software Engineering (AOSE) aims to find
abstractions, languages, methodologies and toolkits for modeling, verifying,
validating and prototyping complex applications conceptualized as Multiagent
Systems (MASs). A very lively research sub-field studies how formal methods can
be used for AOSE. This paper presents a detailed survey of six logic-based
executable agent specification languages that have been chosen for their
potential to be integrated in our ARPEGGIO project, an open framework for
specifying and prototyping a MAS. The six languages are ConGoLog, Agent-0, the
IMPACT agent programming language, DyLog, Concurrent METATEM and Ehhf. For each
executable language, the logic foundations are described and an example of use
is shown. A comparison of the six languages and a survey of similar approaches
complete the paper, together with considerations of the advantages of using
logic-based languages in MAS modeling and prototyping.Comment: 67 pages, 1 table, 1 figure. Accepted for publication by the Journal
"Theory and Practice of Logic Programming", volume 4, Maurice Bruynooghe
Editor-in-Chie
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
- …