There were 105 registered attendees and meeting was considered very useful and successful. Some useful Contact coordinates are:

1. http://www.npac.syr.edu/projects/javaforcse/ is a URL linking to this event and precursor meeting at Syracuse. These links hold papers from both events.
2. The mail reflector java-for-cse@npac.syr.edu can be joined at the above URL.
3. The June 21 papers can be seen at http://www.npac.syr.edu/projects/javaforcse/acmprog/prog.html

which also links to other resources (such as attendee list)

4. The first Syracuse conference proceedings are available as a Special Issue of Concurrency:Practice and Experience (June 1997) and the PPoPP workshop papers will be published similarly in next 6 months.

We discussed two sets of follow-up. Firstly a set of focused meetings with a small group to work with Sun HPC/SunSoft/JavaSoft to help Java evolve to be an excellent language and environment for Scientific Computing. More generally we suggested development of Java Frameworks for Computing which could play the analogous role to (High Performance) Computing that JDBC does for databases and Java. This is described in section III below. In section II, we list briefly some of the points raised in discussion during the conference – especially in the final panel session. These are largely aimed at Java as a language for scientific and engineering computation.

As another follow-up, many believe that another broad scope meeting such as the Syracuse and Las Vegas workshops would be valuable in about 6 months. It was suggested that if held in Silicon Valley, we could write the call for contributions to entice participation from the local industry; for instance from those writing commercial high performance Java systems.

1. We have an opportunity to put the accumulated wisdom of 50 years of Scientific and Engineering Computation into Java and its runtime. (Comment from SunSoft)
2. An endeavor such as 1) implies development of experimental implementations of a Java Scientific Computing Environment and then iterating the standard cycle
   à Specification à Public View à Feedback à
3. What is the role of Java in Industry, Government and academia as measured by impact on bottom line as measured by Improved commerce/products, Improved National Security or Improved research respectively. What current features will and what missing features would lead to significant enhancements in bottom line?
4. The roles of Java in respectively

• Graphical User Interface
• Coordination or Integration of modules
• Numerical Computing

will have different acceptance among users and different issues attached to them!

1. Note that in Grand Challenge and other such large scale simulations, there is a clear movement towards dynamic irregular applications and heterogeneous metcomputing. These are precisely areas where Java has particular added value.
2. As one example note that financial industry considers the (perhaps potential(!)) security features of Java an important bottom line enhancer. They also like Java for Graphical User Interfaces
3. Note that it is easier to change the Java language than its VM (Virtual Machine). For instance adding a complex simple type to language need not change VM whereas a complex array would change VM if stored in obvious way with real and complex adjacent to each other in memory.
4. What is importance of decompilers (from JavaVM bytecodes to Java) which seem surprisingly successful?
5. What is role of preprocessors of some extended Java to "conventional" Java?
6. We reviewed the heated discussion on the importance of adhering to some of Java’s "strict rules" which could be more important in applet mode than in specific machine dependent compilers of Java to native machine code. The requirement that Java give the same numerical result on every computer carries with it some performance penalty and clearly has both strong supporters and eloquent critics. This implies the notion of compiler flags such as -zealot (adhere to all Java rules whatever cost) and -peakflops (get peak performance at any cost).

1. The requirement that Java give the same numerical result on every computer penalizes the X86 architecture which does "better" (higher internal 80 bit precision) arithmetic "faster" in non Java compliant mode.
2. Threads make deterministic (and hence achievement of reproducible results) execution hard! Does this mean that goal of ( see 1) above and 10) in first group) universal results and hence fixed numerical expression evaluation, is unrealistic?
3. How can one compile Java (optimally) to account of data locality and memory hierarchy. Note Java automatic memory management makes this less clear than Fortran C and C++ which have a clear memory layout. It was remarked that use of inner classes (introduced in JDK 1.1) helps this.
4. Is JavaVM and in particular its threads always going to assume a shared memory model or will distributed memory versions become available?
5. The threads of the JavaVM should run efficiently in parallel on an SMP! This natural expectation is not always true today.
6. C++ has extreme overloading which should not be adopted by Java. However modest enhancements such as an overhead free overloaded "+" operator would be important.
7. What do parameterized C++ classes map into with Java?
8. Complex can be introduced either as a primitive type or as a "class with overloaded operators". However current Java classes are slower than simple types (by a large and unacceptable factor) and further as no overloading can only be used for "complex" by using unnatural syntax for +,* etc.
9. We need efficient multidimensional arrays.
10. Use of int (32 bits) for array sizes and lack of a "quad" floating point will eventually be a problem.
11. We need to incorporate BLAS (Basic Linear Algebra) into Math class.
12. Java3D will be an important scientific lbrary
13. What about Fortran90 like array syntax such as sections in Java?

This is based on presentation of Geoffrey Fox and Wojtek Furmanski ( http://www.npac.syr.edu/users/gcf/javaframejune97/ ).

We can imagine several possible (components of) Java Frameworks for Computing

• Numerical Computing Framework: library interfaces, (sparse) matrix storage, complex, evaluation rules, IEEE floating point support, "BLAS". See notes in Section II above!
• Computing Services Framework: Enables Interoperable web compute interfaces,
• Distributed Computing Framework: Network of Java Servers, Object Brokers and Database-Computer links
• High Performance Framework: Parallel Computing, I/O, Parallel Databases and Object Brokers, Java MPI Interface
• Distributed Simulation Framework: Java implementations of DMSO HLA and DIS standards

These are too many aspects of a Java computing framework to tackle at once and probably several are rather controversial as there is no agreed model of the use of Web in Computing.

Perhaps the most promising for early consideration are 1) The Numerical Computing Framework which is essentially use of Java in Computational Science and Engineering and 2) The Computing Services Framework for which we now give a little more detail.

The proposed Java Computing Services Framework enables development of Web Interfaces to run a given job on any computer compliant with this framework just as JDBC gives a universal Web(Java) interface to any relational database. The Computing Services Framework defines universal Java interfaces for Compiling, Executing, Scheduling jobs as in Codine or LSF, Performance monitoring and logging, Debugging, Accessing and storing into File Systems, Visualization Interface (how applets access server side information)

An agreement to a Java Computing Framework would allow vendors to compete on User Front End (GUI) or back end services with the framework linking these. One would expect that the framework is implemented as a set of drivers which map generic Java Interfaces to particular software (e.g. a compiler) on particular machines.