Platform Ontologies

• Back to the PlatformKit main page

The PlatformKit tool uses platform ontologies to reason about platform dependencies introduced by model-driven software artefacts, such as models and model transformations. These ontologies provide a base vocabulary that explains what a “platform” is. Ontologies that are specific to a particular platform, such as Java, can be defined on top of this general platform vocabulary.

This page describes the general base platform vocabulary as well as a description of several Java-based platforms.

This OWL ontology describes units of measurement:

• Units.owl (version 2005/01)

This is the base vocabulary OWL ontology for platforms:

• Platform.owl (version 2007/01)

A simplified diagram of the concepts introduced by the platform ontology is given below:

The Platform concept in this ontology can provide Features, which can take the form of Software or Hardware. This is denoted by the providesFeature property. A '*' next to the property names denotes a one-to-many relationship. Software and Hardware are broken down into different sub-concepts. This is denoted by the special isa subsumption relationship, e.g. the set of operating systems subsumes the set of software in general. Features can require other features, e.g. the need for a particular VirtualMachine or a user interface RenderingEngine that supports voice communication. This is denoted by the requiresFeature property, which represents the transitive closure of required features.

The Java ontologies consist of one main Java ontology that describes the general domain of Java platforms and several Java API ontologies that describe what each particular Java standard provides to the software developer. While the general Java ontology is handwritten, just like the base platform ontologies, the Java API ontologies are generated from the class libraries that come with the various Java development kits. The generation of these ontologies also serves as a use case for the Eclipse MoDisco project.

First, the Java API is reverse engineered from the class library JAR files using the Jar2UML tool. This results in a UML model that describes the class structure of the API.

Next, the generated UML models are transformed to OWL ontologies using the UML2ToPackageAPIOntology.atl model transformation and the IODT ontology framework. This transformation is superimposed on top of the UML2ToAPIOntology.atl model transformation, which contains all the OCL logic for calculating package dependencies. It also contains OCL logic to calculate compatibility relationships between the various Java APIs. Compatibility is only calculated up to a certain extent: compatibility and equivalence is calculated at package level, not at class/interface level. This results in sometimes unexpected incompatibilities between Java packages that one would expect to be backward compatible. The causes of these incompatibilities can be found in the build log of the model transformations that built the Java API ontologies.

Finally, the generated ontologies are hand-checked using the build log and the UML models of the Java APIs. The OWL XML syntax is also slightly adapted to be readable by the Jena framework.

Even though the generated ontologies are reusable, model transformation performance is an important factor. Everytime an improved version of the ontologies must be generated, the ATL transformation needs to be run again on all UML models. The runtime of a single ATL transformation run can go up to 90 minutes for an optimised transformation on the J2SE 1.5 UML model (12 MB) executed on Intel Core2 architecture. Since several runs of this transformation are necessary (one for each Java platform), the need for parallel execution becomes clear.

The transformations are currently run on an dual QuadCore Xeon server @ 2.33 GHz with 8 GB of RAM. Executing all transformation runs in parallel requires more RAM than running them sequentially: currently, 2GB of RAM are used during transformation.

This is the OWL ontology that describes Java platforms in general:

• Java.owl (version 2007/01)

A simplified diagram of the concepts introduced by the Java ontology is given below:

The following ontologies are all generated and can be accessed from the JavaAPI.owl ontology, which imports the entire collection of generated API ontologies.

The Java JDK 1.1 is the first version of Java that became popular. It was meant for the desktop computer. The ontology for the JDK 1.1 contains a comparison against the API of Personal Java 1.1.

The Java JDK 1.2 was called Java 2 Standard Edition to reflect the many changes since version 1.1. This is also the first Java version that separated the development kit (JDK) from the runtime environment (JRE). J2SE was also meant for the desktop computer. The ontology for J2SE 1.2 contains a comparison against the API of JDK 1.1 and J2ME MIDP 1.0.

Java 2 Standard Edition 1.3 is an evolution from J2SE 1.2. The ontology for J2SE 1.3 contains a comparison against the API of J2SE 1.2 and J2ME PP 1.0.

Java 2 Standard Edition 1.4 adds assertions and several API extensions compared to J2SE 1.3. The ontology for J2SE 1.4 contains a comparison against the API of J2SE 1.3.

Java 2 Standard Edition 1.5 is a major extension of J2SE 1.4, adding generics amongst other things. It is also called Java 5 Standard Edition. The ontology for J2SE 1.5 contains a comparison against the API of J2SE 1.4.

Java 2 Standard Edition 1.6 is an extension of J2SE 1.5. It is also called Java 6 Standard Edition. The ontology for J2SE 1.6 contains a comparison against the API of J2SE 1.5.

Java 2 Mobile Edition - Mobile Information Device Profile version 1.0 is the Java version for small mobile devices, such as mobile phones. Its API is very limited, hence it is not compared against other APIs. Instead, other APIs may compare against this API.

Java 2 Mobile Edition - Mobile Information Device Profile version 2.0 is the Java version for small mobile devices, such as mobile phones. It is the successor of J2ME MIDP 1.0.

Personal Java is the predecessor of J2ME Personal Profile. It is an early version of Java for mobile devices, mostly PDAs. It is derived from JDK 1.1, but is stripped in several places. The ontology for Personal Java 1.1 contains a comparison against the API of J2ME MIDP 1.0. The UML model of the API is not reverse engineered, but derived from the JDK 1.1 API model using the comparison specification from Sun Microsystems.

Java 2 Mobile Edition - Personal Profile version 1.0 is the Java version for more sophisticated mobile devices, such as PDAs. It is derived from J2SE 1.3, with several packages removed and some packages added. J2ME PP 1.0 shares the javax.microedition.io package with J2ME MIDP 1.0. The UML model of the J2ME PP 1.0 API has been derived from the J2SE 1.3 API and the J2ME MIDP 1.0 API and has been edited by hand to match the specification. The ontology for J2ME PP 1.0 contains a comparison against the API of J2ME MIDP 1.0.

Java 2 Mobile Edition - Personal Profile version 1.1 is the Java version for more sophisticated mobile devices, such as PDAs. It is derived from J2SE 1.4, with several packages removed and some packages added. It also is the successor of J2ME PP 1.0.

Even though Java is meant to be portable across different operating systems, there is not always a packaging framework available within the Java environment itself. Java applets and Java Web Start only work on desktop/laptop machines, while Java midlets only work on MIDP devices. J2ME Personal Profile devices and Personal Java devices must use the packaging framework provided by the OS (e.g. CAB files for Windows CE or IPK files for Qtopia/Linux).

This is why a limited ontology of OS-specific package managers is also provided: