Semantics
We are seeking comments on the final draft of our ICFP 2006 paper: Delimited dynamic binding, by Oleg Kiselyov, Chungchieh Shan, and Amr Sabry.
Dynamic binding and delimited control are useful together
in many settings, including Web applications, database cursors, and
mobile code. We examine this pair of language features to show that the
semantics of their interaction is illdefined yet not expressive enough
for these uses.
We solve this open and subtle problem. We formalise a typed language
DB+DC that combines a calculus DB of dynamic binding and a calculus
DC of delimited control. We argue from theoretical and practical
points of view that its semantics should be based on delimited
dynamic binding: capturing a delimited continuation closes over
part of the dynamic environment, rather than all or none
of it; reinstating the captured continuation supplements
the dynamic environment, rather than replacing or inheriting it. We
introduce a type and reductionpreserving translation from DB+DC to DC,
which proves that delimited control macroexpresses dynamic
binding. We use this translation to implement DB+DC in Scheme, OCaml,
and Haskell.
We extend DB+DC with mutable dynamic variables and a facility to
obtain not only the latest binding of a dynamic variable but also
older bindings. This facility provides for stack inspection and (more
generally) folding over the execution context as an inductive data
structure.
The paper comes with a large amount of
accompanying code—in Scheme, OCaml, SML, and Haskell. The code (described in the paper's appendix) uses realistic examples to show how the joint behavior of delimited continuations
and dynamic binding is illdefined in various PL systems, and solves the problem by a
fullfledged implementation of dynamic binding in all these systems. Any comments or suggestions would be very welcome!
Nested commits for mobile calculi: extending Join
by Roberto Bruni, Hernan Melgratti, Ugo Montanari
In global computing applications the availability of a mechanism for some form of committed choice can be useful, and sometimes necessary. It can conveniently handle, e.g., contract stipulation, distributed agreements, and negotiations with nested choice points to be carried out concurrently. We propose a linguistic extension of the Join calculus for programming nested commits, called Committed Join (cJoin).
It provides primitives for explicit abort, programmable compensations and interactions between ongoing negotiations. We give the operational semantics of cJoin in the reflexive CHAM style. Then we discuss its expressiveness on the basis of a few examples and of the cJoin encoding of other paradigms with similar aims but designed in different contexts, namely AKL and ZeroSafe nets.
To me the main interest lies in section 4.2, which shows an encoding of a subset of AKL in cJoin.
More references to relationships between logic/constraint and "pifamily" approaches to concurrency are welcome!
Continuations for Parallel Logic Programming
by Eneia Todoran and Nikolaos S. Papaspyrou
This paper gives denotational models for three logic programming
languages of progressive complexity, adopting the
"logic programming without logic" approach. The first language
is the control ow kernel of sequential Prolog, featuring
sequential composition and backtracking. A committedchoice
concurrent logic language with parallel composition
(parallel AND) and don't care nondeterminism is studied
next. The third language is the core of Warren's basic Andorra
model, combining parallel composition and don't care
nondeterminism with two forms of don't know nondeterminism
(interpreted as sequential and parallel OR) and favoring
deterministic over nondeterministic computation. We show
that continuations are a valuable tool in the analysis and
design of semantic models for both sequential and parallel
logic programming. Instead of using mathematical notation,
we use the functional programming language Haskell
as a metalanguage for our denotational semantics, and employ
monads in order to facilitate the transition from one
language under study to another.
This paper happens to combine several topics that interest me lately  AKL (a precursor of Oz), denotational semantics, continuations, and implementing programming languages in Haskell.
If you share at least some of these interests  take a look!
Modeling Languages: Syntax, Semantics and all that Stuff (or, What's the Semantics of "Semantics"?)
by David Harel, Bernhard Rumpe
Motivated by the confusion surrounding the proper definition of complex modeling languages, especially the UML, we discuss the distinction between syntax and true semantics, and the nature and purpose of each.
This paper is rather light on greek letters (and category stuff is absent as well). Instead, it aims to introduce the notions of syntax, semantics, and formal definition of languages in plain prose.
If you never understood why bother with formal definitions  consider reading this!
You might want to read a longer version (Modeling Languages: Syntax, Semantics and All That Stuff Part I: The Basic Stuff). Unfortunately, I was unable to find parts II and III (The Advanced Stuff and The Really Hard Stuff) online.
Two new papers by Paul Blain Levy, "Jumbo Lambda Calculus" and the extended version "Jumbo Connectives in Type Theory and Logic", are available on his web page. Part of the abstract:
We make an argument that, for any study involving computational effects such as divergence or continuations, the traditional syntax of simply typed lambdacalculus cannot be regarded as canonical, because standard arguments for canonicity rely on isomorphisms that may not exist in an effectful setting. To remedy this, we define a "jumbo lambdacalculus" that fuses the traditional connectives together into more general ones, socalled "jumbo connectives". We provide two pieces of evidence for our thesis that the jumbo formulation is advantageous.
(From the types list.)
Building Interpreters by Composing Monads
We exhibit a set of functions coded in
Haskell that can be used as building blocks to construct
a variety of interpreters for Lisplike languages. The
building blocks are joined merely through functional
composition. Each building block contributes code to
support a specific feature, such as numbers, continuations,
functions calls, or nondeterminism. The result of
composing some number of building blocks is a parser,
an interpreter, and a printer that support exactly the
expression forms and data types needed for the combined
set of features, and no more.
The data structures are organized as pseudomonads,
a generalization of monads that allows composition.
Functional composition of the building blocks implies
type composition of the relevant pseudomonads.
So actually it is about building interpreters by composing pseudomonads.
PS: I stumbled upon this paper while trying to factor an interpreter into a set of features (and yes, I tried to package them as monads).
After a day of fighting with undecidable instances and rigid type variables I gave up and started googling  well, I was trying to invent a wheel.
Any comments on how pseudomonads relate to arrows (and other generalizations of monads) are appreciated.
Typed Concurrent Programming with Logic Variables
We present a concurrent higherorder programming language called Plain and a
concomitant static type system. Plain is based on logic variables and computes
with possibly partial data structures. The data structures of Plain are procedures, cells, and records. Plain's type system features recordbased subtyping, bounded existential polymorphism, and access modalities distinguishing between reading and writing.
You may want to compare this with The Oz Programming Model (OPM), which
... is a concurrent programming model subsuming higherorder functional and objectoriented programming as facets of a general model. This is particularly interesting for concurrent objectoriented programming, for which no comprehensive formal model existed until now. The model can be extended so that it can express encapsulated problem solvers generalizing the problem solving capabilities of constraint logic programming.
Another paper on OPM is The Operational Semantics of Oz.
In short, the model of Plain is based on that of Oz with the main differences being:
 Plain statically types programs using a type system with subtyping, while Oz is latently typed.
 Therefore Plain chooses to drop support for unification in favor of a singleassignment operation.
A Monadic Semantics for Core Curry
The structure of our semantics sheds some light on how the basic components
of the language interact. In particular, we can see that the addition
of nondeterminism, logic variables and narrowing can be accomplished just
by making a suitable shift in interpretation monad. We could emphasize
this modularity further by presenting the relevant monads as compositions of
monad transformers.
While being primarily an "interpreter as semantics" paper, it looks like a nice example of a DSL in Haskell.
As a bonus, it also discusses some features of logic programming.
A TailRecursive Machine with Stack Inspection. John Clements and Matthias Felleisen, TOPLAS 2004.
Security folklore holds that a security mechanism based on stack inspection is incompatible with a global tail call optimization policy... In this article, we prove this widely held belief wrong. ... Our machine is surprisingly simple and suggests that tail calls are as easy to implement in a security setting as they are in a conventional one.
I don't believe we've discussed this paper before, although it was mentioned in this thread. Tail calls have been a topic of discussion here several times. [1][2][3]
Following the story on Mind Mappers and other RDF comments of late, I thought this NLP slide show (PDF) should get a story. Dr. Adrian Walker offers an interesting perspective in a friendly crayoncolored format, including a critique of RDF. Source site Internet Business Logic has other offerings including an online demo.

Recent comments
1 week 1 day ago
1 week 2 days ago
1 week 2 days ago
1 week 2 days ago
1 week 2 days ago
1 week 2 days ago
1 week 2 days ago
1 week 2 days ago
1 week 2 days ago
1 week 2 days ago