From http://hpc.doc.ic.ac.uk/~jpc1/thought.html:

reuse and lazy evaluation (April 1996)
(Idea came partly from Chalmers). Lazy evaluation allows more reuse of software because the same code can be reused with different evaluation orders. This, like the reuse that you get with Prolog where a function can be reused as its inverse, is the sort of benefit that you get from using a high level language.

lazy evaluation and optimization (March 1996)
For optimizing communication it is necessary to know exactly when particular values are needed so that communication can be ordered and spread out. Lazy evaluation does exactly this: it is an algorithm for calculating necessary execution orders (dynamically when there are dynamic dependencies). It does not tell you which instruction to execute, so there is flexibility to reorder to optimise communication. However there is the non termination problem if the outermost redex is not selected for evaluation, so it might not be much use. Maybe strictness analysis is better: if a function is known to be strict in two arguments then we can schedule these in a communication optimal order, if we can estimate (say) minimum execution times. This works in strict languages too, but not with side effects. (Slightly related, see Paul Kelly, A lazy, self-optimising parallel matrix library).

lazy synchronisation (February 1996)
Can lazy evaluation techniques be used to structure task-pool type parallel algorithms, or to implement algorithms that are conceptually like this? Lazy evaluation is a way of prioritizing tasks to be executed, depending on whether/when they are needed. Lazy synchronisation may be the parallel equivalent. Each processor decides which task of the ones it currently has allocated to do first depending on the synchronization function. If tasks are assigned to more than one machine they can either be killed by message passing or, more simply, ignored later. For something closer to a task pool load balancing requires that each processor can always execute one task, which is most likely if the task/processor ratio is high, and if the synchronisation is not global, eg if only adjacent pairs of processors need to synchronise.

laziness (February 1996)
Live Picture is the first piece of commercial software I know of that actually uses lazy evaluation as a selling point. Could be used for other things too, such as lazy spreadsheets that only evaluate cells that you can see, making the system much faster. Of course you can then try to guess what the user might want and evaluate this in the background.

lists in lazy languages (January 1996)
Lists in lazy functional languages are not data structures they are control structures - basically loops. This is why they are such a natural structure. Having functions (eg takewhile) which act on lists/loops is a very useful and powerful higher order programming concept. It is not clear that a data structure means much as a concept except as a processing order.