Lambda the Ultimate

Generative Code Specialisation for High-Performance Monte-Carlo Simulations

...we use functional programming to reconcile high performance and generality in simulators based on Monte-Carlo simulation. Moreover, we have successfully parallelised the kinetics simulation, which required a new technique as the simulation is based on a Markov-chain. This makes out approach future proof in the light of the current trend in hardware to add extra parallelism instead of increasing single-threaded performance.

The Structure and Value of Modularity in Software Design, K.J. Sullivan, W.G. Griswold, Y. Cai, B. Hallen.

The concept of information hiding modularity is a cornerstone of modern software design thought, but its formulation remains casual and its emphasis on changeability is imperfectly related to the goal of creating value in a given context. We need better models of the structure and value of information hiding, for both their explanatory power and prescriptive utility. We evaluate the potential of a new theory—developed to account for the influence of modularity on the evolution of the computer industry — to inform software design. The theory uses design structure matrices to model designs and real options techniques to value them. To test the potential utility of the theory for software we represent a model software system in its terms—Parnas’s KWIC—and evaluate the results. We contribute an extension to design structure matrices and show that the options results are consistent with Parnas’s conclusions. Our results suggest that such a theory does have potential to help inform software design.

This is really neat stuff; the authors use options theory to estimate the added value of a modular design relative to a less-modular design. It's always nice when an informal engineering intuition can be analyzed more precisely.

I recently made the final revisions of the paper on Typing Functional Stack-Based Languages and submitted it to ICFP. A big thank your to everyone here at Lambda-the-Ultimate.org for their help, especially regular LtU contributor Andreas Rossberg who played a big part in defining the type system.

I have had several requests for an easier to follow explanation of how a type inference engine would work for a functional stack-based language, so I've written a short article for those interested which walks step by step through an example of how to infer types for a complex higher order function "eval(eval(noop)))" or in Cat "[] eval eval".

Any questions, suggestions, or corrections would be most welcome.