High-level specification of patterns of communications such as protocols can be modeled elegantly by means of session types (Honda et al., 1998). However, a number of examples suggest that session types fall short when finer precision on protocol specification is required. In order to increase the expressiveness of session types we appeal to the theory of correspondence assertions (Clarke & Marrero, 1998; Gordon & Jeffrey, 2003b). The resulting type discipline augments the types of long-term channels with effects and thus yields types which may depend on messages read or written earlier within the same session. This new type system can be used to check:

1. source of information,

2. whether data is propagated as specified across multiple parties,

3. if there are unspecified communications between parties, and

4. if the data being exchanged has been modified by the code in an unspecified way.

Functional programming fits well with the use of descriptive markup in HTML and XML. There is also a good fit between S-expressions in Lisp and the XML data set. These similarities are exploited in LAML which is a software package for Scheme. LAML supports exact mirrors of the three variants of XHTML 1.0, SVG 1.0, and a number of more specialized XML languages. The mirrors are all synthesized from document type definitions (DTDs). Each element in a mirror is represented by a named function in Scheme. The mirror functions validate the XML document while it is generated. The validation is based on finite state automata automatically derived from the DTD.

We introduce a quantitative approach to the analysis of distributed systems which relies on a linear operator based network semantics. A typical problem in a distributed setting is how information propagates through a network, and a typical qualitative analysis is concerned with establishing whether some information will eventually be transmitted from one node to another node in the network. The quantitative approach we present allows us to obtain additional information such as an estimation of the probability that some data is transmitted within a given interval of time. We formalise situations like this using a probabilistic version of a process calculus which is the core of KLAIM, a language for distributed and mobile computing based on interactions through distributed tuple spaces. The analysis we present exploits techniques based on Probabilistic Abstract Interpretation and is characterised by compositional aspects which greatly simplify the inspection of the nodes interaction and the detection of the information propagation through a computer network.

The parallel-functional language Eden has a non-deterministic construct, the process abstraction merge, which interleaves a set of input lists to produce a single non-deterministic list. Its non-deterministic behaviour is a consequence of its reactivity: it immediately copies to the output list any value appearing at any of the input lists. This feature is essential in reactive systems and very useful in some deterministic parallel algorithms. The presence of non-determinism creates some problems such that some internal transformations in the compiler must be disallowed. The paper describes several non-determinism analyses developed for Eden aimed at detecting the parts of the program that, even in the presence of a process merge, still exhibit a deterministic behaviour. A polynomial cost algorithm which annotates Eden expressions is described in detail. A denotational semantics is described for Eden and the correctness of all the analyses is proved with respect to this semantics.

This paper presents SKRIBE, a functional programming language for authoring documents, especially technical documents such as web pages, technical reports, and API documentation. Executing Skribe programs can produce documents in various formats, such as PostScript, PDF, HTML, Texinfo, or Unix man pages. That is, the very same Skribe program can be used to produce documents in different formats. Skribe is a full featured programming language whose syntax makes it look like a markup language à la HTML.

For the sake of the example, here is the whole SKRIBE source code for the paragraph above:

(p [This paper presents ,(Skribe), a functional programming language for authoring documents, especially technical documents such as web pages, technical reports, and API documentation. Executing Skribe programs can produce documents in various formats, such as PostScript, PDF, HTML, Texinfo, or Unix man pages. That is, the very same Skribe program can be used to produce documents in different formats. Skribe is a full featured programming language whose syntax makes it look like a markup language à la HTML.])

SKRIBE can be downloaded at: http://www.inria.fr/mimosa/fp/Skribe.

We present a rule-based framework for the development of scalable parallel high performance simulations for a broad class of scientific applications (with particular emphasis on continuum mechanics). We take a pragmatic approach to our programming abstractions by implementing structures that are used frequently and have common high performance implementations on distributed memory architectures. The resulting framework borrows heavily from rule-based systems for relational database models, however limiting the scope to those parts that have obvious high performance implementation. Using our approach, we demonstrate predictable performance behavior and efficient utilization of large scale distributed memory architectures on problems of significant complexity involving multiple disciplines.

We explore the logical underpinnings of higher-order, security-typed languages with mutable state. Our analysis is based on a logic of information flow derived from lax logic and the monadic metalanguage. Thus, our logic deals with mutation explicitly, with impurity reflected in the types, in contrast to most higher-order security-typed languages, which deal with mutation implicitly via side-effects. More importantly, we also take a store-oriented view of security, wherein security levels are associated with elements of the mutable store. This view matches closely with the operational semantics of low-level imperative languages where information flow is expressed by operations on the store. An interesting feature of our analysis lies in its treatment of upcalls (low-security computations that include high-security ones), employing an “informativeness” judgment indicating under what circumstances a type carries useful information.

We analyse machines that implement the call-by-value reduction strategy of the λ-calculus: two environment machines – CAM and SECD – and two encodings into the $\pi$-calculus – due to Milner and Vasconcelos. To establish the relation between the various machines, we setup a notion of reduction machine and two notions of correspondences: operational – in which a reduction step in the source machine is mimicked by a sequence of steps in the target machine – and convergent – where only reduction to normal form is simulated. We show that there are operational correspondences from the λ-calculus into CAM, and from CAM and from SECD into the $\pi$-calculus. Plotkin completes the picture by showing that there is a convergent correspondence from the λ-calculus into SECD.

This paper proposes new syntactic inference rules which can directly extract information flow in a given typed process in the π-calculus. In the flow analysis, a flow in a process is captured as a chain of possible interactions which transform differences in behaviours from one part of its interface to another part of its interface. Polarity in types plays a fundamental role in the analysis, which is elucidated via examples. We show that this inductive flow analysis can be used for giving simple proofs of noninterference in the secrecy analyses for the π-calculus with linear/affine typing, including its concurrent, stateful extensions.

Type theory was invented at the beginning of the twentieth century with the aim of avoiding the paradoxes which result from the self-application of functions. $\lambda$-calculus was developed in the early 1930s as a theory of functions. In 1940, Church added type theory to his $\lambda$-calculus giving us the influential simply typed $\lambda$-calculus where types were simple and never created by binders (or abstractors). However, realising the limitations of the simply typed $\lambda$-calculus, in the second half of the twentieth century we saw the birth of new more powerful typed $\lambda$-calculi where types are indeed created by abstraction. Most of these calculi use two binders $\lambda$ and $\Pi$ to distinguish between functions (created by $\lambda$-abstraction) and types (created by $\Pi$-abstraction). Moreover, these calculi allow $\beta$-reduction but not $\Pi$-reduction. That is, $(\pi_{x:A}.B)C \rightarrow B[x:=C]$ is only allowed when $\pi$ is $\lambda$ but not when it is $\Pi$. This means that, modern systems do not allow types to have the same instantiation right as functions. In particular, when $b$ has type $B$, the type of $(\lambda_{x:A}.b)C$ is taken immediately to be $B[x:=C]$ instead of $(\Pi_{x:A}.B)C$. Extensions of modern type systems with both $\Pi$-reduction and type instantiation have appeared in (Kamareddine, Bloo and Nederpelt, 1999; Kamareddine and Nederpelt, 1996; Peyton-Jones and Meijer, 1997). This makes the $\lambda$ and $\Pi$ very similar and hence leads to the obvious question: why not use a unique binder instead of the $\lambda$ and $\Pi$? This makes more sense since already, versions of de Bruijn's Automath unified $\lambda$ and $\Pi$ giving more elegant systems. This paper studies the main properties of type systems with unified $\lambda$ and $\Pi$.