In this technical report, we have presented a new programming paradigm involving a three-stage contract between four participants. The participants are: the end user, the application program, the system software, and the hardware specification file. An end user is a person wishing to execute some application but is not assumed to know or care about the architecture, topology, or any machine-specific details. The application programmer engages in a dialog with the compiler to produce an ``application program'' -- a suite of many different, best-known algorithms that cover a wide range situations. Each application program is tagged by the compiler with timing, accuracy, cost, and reliability estimates. This information is used in turn to match the end user with the most appropriate algorithm. It may be the case that no such algorithm exists that can meet the end user's requirements. In such a case, contract negotiations may ensue to relax end user requirements. Finally, the hardware specification file contains all of the information specific to a particular platform. This information is used to help determine timing, cost, and reliability estimates. The file's topological details also help in the selection of the appropriate algorithm for a particular machine.
Obviously, we cannot give all the details of our scheme in this summary. Rather, we would like to reiterate that the main contribution here is the new way in which interactions with the computer are thought of. Now, the user cares only about obtaining acceptably good answers in a reasonable amount of time and within a particular (cash or time) budget. The application program can now focus on the underlying algorithm without presuming compiler and hardware behavior. Finally, the compiler is given the information it really needs: what can be run in parallel and what types of hardware are necessary to do the job.
In the short term, we hope to develop a working prototype. The hardest part will be finding a universal, hardware specification. The compiler is also expected to take a great deal of time. Then, once the prototype is working, a library of routines for a variety of precisions and timing can be developed. Gradually, more target hardwares will be incorporated with an emphasis on parallel platforms. The creation of a robust system capable of handling a wide variety of machines is likely to take ten years or longer.
If we are successful, application programs will be thought of in an entirely new way. For one thing, they will not be dependent on any given language. More importantly, though, the application program (by not specifying any trick code for higher performance) will become immortal as it locks in the essence of the algorithm while ignoring techniques and technology. Such a program could, in theory, need never be rewritten except in the case where the underlying algorithm itself is improved. Then, as these immortal programs are developed, an international clearing house or repository can be set up providing on line access to the code.