Interoperability by exchanging executable content, or what have PostScript and Java in common?

Andrej Vckovski
Spatial Data Handling Division
Department of Geography
University of Zurich


In the area of Geographical Information Systems (GIS) , the requirements posed upon an set of "heterogeneous but interoperable systems" are not easily met. The particular systems most often possess a certain autonomy and are designed to meet specific requirements for the respective application domain their are used in. In order to be more than mere "data exchange", interoperability needs to be based on a framework which is easy to understand for all participating communities and yet expressive enough to meet those application specific requirements.

This contribution shows how "executable content" known from systems such as PostScript or Java can provide a very flexible method to exchange rich information in a way where the data consumer does not need to have the full knowledge of the data producer's application domain.

PostScript has been designed to overcome hardware dependencies on raster output devices when exchanging data describing text and graphical shapes. The heterogeneity of the output devices was addressed by incorporating much of the device specific issues within the device itself and define a standardized data exchange format (contrary to approaches that define a set of device-specific drivers on the data producer side). The data exchanged consist actually of an executable program written in the PostScript language. The device peculiarities are handled by an interpreter for that programming language. The PostScript approach is based on a semantically rich description of the data on a high abstraction level, semantically rich in the sense that the approach is very expressive.

However, the PostScript change history has shown also some drawbacks of this approach. For example, the understanding of data encoded in PostScript" (i.e., a PostScript program or "file") needs a full-blown PostScript interpreter, which is not a trivial thing considering the expressiveness of the language. This contribution discusses some of the lessons learned in PostScript's history.

Java is an object-oriented programming language and distributed computing environment which has gained a lot of in the last few years (however, partly due to excellent marketing activities). One of the core concepts of Java is the same as used in PostScript and other interpreted languages: Hardware and operating system heterogeneities are resolved by interpreting a well-defined format on the target platform. However, unlike PostScript Java uses an intermediary format ("byte-code") which makes this stage of execution somewhat independent on the language itself (i.e., Java byte code needs not necessarily to be produced by a Java-compiler).

Java offers also other features which make it even more suitable for the exchange of information in an heterogeneous world:

The contribution will discuss some of these features of Java and give some examples on how Java can be used as a framework for interoperability, a framework which is based on the exchange of executable content.