OCCAM, JOYCE, SUPERPASCAL AND JAVA

[Per Brinch Hansen <pbh@xxxxxxxxxxxxxxx>]

To: P.H.Welch@xxxxxxxxx
From: pbh@xxxxxxxxxxxxxxx
CC: b.m.cook@xxxxxxxxxxxxxx, java-threads@xxxxxxxxx,
  occam-com@xxxxxxxxx, pbh@xxxxxxxxxxxxxxx
Date: 22 May 1999 
Subject: OCCAM, JOYCE, SUPERPASCAL AND JAVA


Dear Peter,

Here is a partial response to your email of May 20:

When I first heard about Java it was immediately obvious
to me that it was being marketed as a consumer product
(rather than a scientific notation). So I paid no attention
to it for several years. When I finally got around to
looking at Java's parallelism I concluded that its designers
were amateurs who were completely out of their depth.

To avoid being asked by anonymous reviewers to tone it
down, I decided to publish my criticism in SIGPLAN Notices
[17]. SIGPLAN Notices limits all contributions to eight
pages. By coincidence that is exactly the length of my
article. Now, eight pages forced me to stick to one theme
only. So I carefully explained by example that Java never
got beyond my earliest ideas in parallel programming - and
got them all wrong! I was not advocating the use of these
early ideas today. If I had had more space, I would have
explained that the final monitor concept in Concurrent
Pascal did not use waiting loops [2]. I would also have
liked to point out that Java threads are beyond repair in
the sense that they make interference check impossible in
general [14]. So forgive me for omitting occam this time.

I have, however, experimented with the CSP concepts and
occam for many years at Syracuse University:

>From 1987 to 1989 I designed the programming language
Joyce, based on CSP and Pascal, and implemented it on an
Encore Multimax with 18 processors connected to a shared
memory [3-8]. Joyce supports both input and output polling.

In 1989, a Computing Surface with 48 T800 transputers was
installed in my lab at Syracuse. I spent five years using
this wonderful multicomputer to write parallel occam
programs for computational science [9-11, 15].

By 1994 I had also designed and implemented the parallel
publication language SuperPascal based on CSP and occam
[12-16].

In contrast to occam, Joyce and SuperPascal both support
recursive process activation. It took me thirty years to
solve the problem of reclaiming the storage of parallel
recursion without garbage collection [16]. But now that the
problem has been solved I would expect future programming
languages to support efficient parallel recursion as a
matter of course.

So I am well aware of the advantages of occam. I was,
however, unaware of the recent work involving occam and
its successors. This is partly my fault since I don't read
as much about parallel programming as I used to. However,
it also seems to me that the internet makes it too easy to
communicate with a small group of insiders and makes it
less attractive to publish papers in widely read journals,
such as IEEE Computer and SIGPLAN Notices.

You were selected to receive my paper because I found a
Web page of WoTUG Committee Members by chance. Even so, I
had to look you up individually to find your mailing
addresses. The internet is perhaps not always the best way
to reach a wider audience. (Alta Vista found 185 Web pages
for "parallel java" and 8693 pages for "occam".)

I would encourage you (and your fellow occam fans) to do two
things:

* Write letters to the editor of SIGPLAN Notices and express
  your own opinions about Java's parallelism.

* Present your arguments in a carefully reasoned papers for
  computer scientists in general.

All the best,

Per Brinch Hansen 



REFERENCES

* Thirty Years of Parallel Programming:

1. Brinch Hansen, P., The Search for Simplicity: Essays in
Parallel Programming. IEEE Computer Society Press, Los
Alamitos, CA, April 1996.

* Monitors and Concurrent Pascal:

2. Brinch Hansen, P., Monitors and Concurrent Pascal: A
personal history. 2nd ACM Conference on the History of
Programming Languages, Cambridge, MA, April 1993. In SIGPLAN
Notices 28, 3 (March 1993), 1-35. Also in T. J. Bergin, Jr.,
and R. G. Gibson (eds.), History of Programming Languages
II, Addison-Wesley, Reading, MA, 1996, 121-172.
 
* The Joyce Language:

3. Brinch Hansen, P., Joyce - a programming language for 
distributed systems. Software - Practice and Experience
17, 1 (January 1987), 29-50.

4. Brinch Hansen, P., A Joyce implementation. Software -
Practice and Experience 17, 4 (April 1987), 267-276.

5. Brinch Hansen, P., and Rangachari, A., Joyce performance
on a multiprocessor. School of Computer and Information
Science, Syracuse University, Syracuse, NY, September 1988.

6. Brinch Hansen, P., The Joyce language report. Software -
Practice and Experience 19, 6 (June 1989), 553-579.

7. Brinch Hansen, P., A multiprocessor implementation of
Joyce. Software - Practice and Experience 19, 6 (June
1989),  579-592.

8. Brinch Hansen, P., Analysis of a parallel mergesort,
School of Computer and Information Science, Syracuse
University, Syracuse, NY, July 1989.

* Occam and SuperPascal:

9. Brinch Hansen, P., Model programs for computational
science: A programming methodology for multicomputers.
Invited paper for Concurrency - Practice and Experience 5, 5
(August 1993), 407-423. 

10. Brinch Hansen, P., Parallel Cellular Automata: A model
program for computational science. Invited paper for
Concurrency - Practice and Experience 5, 5 (August 1993),
425-448.
 
11. Brinch Hansen, P., Do hypercubes sort faster than tree
machines? Concurrency - Practice and Experience 6, 2
(April 1994), 143-151.

12. Brinch Hansen, P., The programming language SuperPascal.
Software - Practice and Experience 24, 5 (May 1994),
467-483.

13. Brinch Hansen, P., SuperPascal - a publication language
for  parallel scientific computing. Concurrency - Practice
and Experience 6, 5 (August 1994), 461-483. 

14. Brinch Hansen, P., Interference control in SuperPascal -
a block-structured parallel language. The Computer Journal
37, 5 (1994), 399-406.

15. Brinch Hansen, P., Studies in Computational Science:
Parallel Programming Paradigms. Prentice-Hall, Englewood 
Cliffs, NJ, March 1995.

16. Brinch Hansen, P., Efficient parallel recursion. SIGPLAN
Notices 30, 12 (December 1995), 9-16.

* Parallel Java:

17. Brinch Hansen, P. Java's insecure parallelism. ACM
SIGPLAN Notices 34, 4 (April 1999), 38-45.