Lambda the Ultimate

Or are they just being lazy? ;-)

A gentle reminder to y'all to post something...

Implicitly Heterogeneous Multi-stage Programming. Jason Eckhardt, Roumen Kaiabachev, Emir Pasalic, Kedar Swadi and Walid Taha

Previous work on semantics-based multi-stage programming (MSP) language design focused on homogeneous languages designs, where the generating and the generated languages are the same. Homogeneous designs simply add a hygienic quasi-quotation and evaluation mechanism to a base language. An apparent disadvantage of this approach is that the programmer is bound to both expressivity and performance charcteristics of the base language. This paper proposes a practical means to show that this can be avoided by providing specialized translations from subsets of the base language to different target languages.

The idea is that the first stage is done in OCaml and the second stage in C or Fortran (or other similar language). The main point is that the output from the first stage is a subset of OCaml (actually, a subset of Ocaml AST), which is more regular and permits efficient translation to C (as compared to what's required in compiling full Ocaml).

The generated C code is, of course, automatically type-correct. As Oleg remarks, this brings us close to the goal of enjoying all benefits of abstractions with no overhead.

More information here.

Matrix Distributed Processing (MDP) is a C++ library for fast development of efficient parallel algorithms. MDP enables programmers to focus on algorithms, while parallelization is dealt with automatically and transparently. Here we present a brief overview of MDP and examples of applications in Computer Science (Cellular Automata), Engineering (PDE Solver) and Physics (Ising Model).

A short tutorial on MDP.

MDP provides a distributed programming model. On top of that, it is interesting to see that the library adds what looks like a language constructs (e.g., forallsites).

A 7-hour lecture given at TECS Week 2005 by Xavier Leroy.

This detailed set of slides explains various security models, and related attacks.

It has been awhile since we discussed mobile code and its security implications, but I am sure everyone realizes this is a major issue, that will only become more important as network applications become more and more pervasive (e.g., via mobile phones).

Speed is often used as an excuse for bad programming (premature optimization is the root of all evil and all that). Yet understanding the causes of poor performance of the language system, as opposed to user code, isn't all that easy.

If you are using an open source language implementation, and have access to something clever like dtrace, it might be easier than you think.

From the abstract of Per Brand's Ph.D. thesis,
The Design Philosophy of Distributed Programming Systems: the Mozart Experience, which has just appeared (dated June 2005):

Distributed programming is usually considered both difficult and inherently different from concurrent centralized programming. It is thought that the distributed programming systems that we ultimately deploy, in the future, when we've worked out all the details, will require a very different programming model and will even need to be evaluated by new criteria.



The Mozart Programming System, described in this thesis, demonstrates that this need not be the case. It is shown that, with a good system design, distributed programming can be seen as an extended form of concurrent programming. This is from the programmer's point-of-view; under the hood the design and implementation will necessarily be more complex. We relate the Mozart system with the classical transparencies of distributed systems. We show that some of these are inherently on the application level, while as Mozart demonstrates, others can and should be dealt with on the language/system level.

[...]

The full range of the design and implementation issues behind Mozart are presented. This includes a description of the consistency protocols that make transparency possible for the full language, including distributed objects and distributed data-flow variables.

A well done set of Python challenges.

Some solutions can be found here, if you need help getting started...

The system consists of a compiler for the Cellang cellular automata programming language, along with the corresponding documentation, viewer, and various tools. Cellang has been undergoing refinement for the last several years, with corresponding upgrades to the compiler...

The most important distinguishing features of Cellang, include support for:

• named constants...
• any number of dimensions
• compile time specification of each dimension's size
• cell neighborhoods of any size (though bounded at compile time) and shape
• positional and time dependent neighborhoods

...

Well, I did ask for a DSL for cellular automata. Here's one...

A one day workshop on Sunday, 25 September at ICFP05.

I don't often post CFPs and the like, but since it's been awhile since FPDE02, and since many here have an active interest in these topics, I made an exception.

Links to interesting projects related to FPDE, are more than welcome.

A type discipline for authorization policies. Cedric Fournet; Andrew D. Gordon; Sergio Maffeis

Distributed systems and applications are often expected to enforce high-level authorization policies. To this end, the code for these systems relies on lower-level security mechanisms such as, for instance, digital signatures, local ACLs, and encrypted communications. In principle, authorization specifications can be separated from code and carefully audited. Logic programs, in particular, can express policies in a simple, abstract manner. For a given authorization policy, we consider the problem of checking whether a cryptographic implementation complies with the policy. We formalize authorization policies by embedding logical predicates and queries within a spi-calculus. This embedding is new, simple, and general; it allows us to treat logic programs as specifications of code using secure channels, cryptography, or a combination. Moreover, we propose a new dependent type system for verifying such implementations against their policies. Using Datalog as an authorization logic, we show how to type several examples using policies and present a general schema for compiling policies.

I guess it's dependent types day around here...