Overview

This page gives a brief overview of the architecture of the Overture platform. The components or modules of the Overture architecture can be categorized according to two points of view on the code base:

• Source Code POV: each architecture module corresponds to a Maven module.
• Functionality POG: more conceptual overview; blurs the lines between modules and simply considers distinct, high-level functionalities.

Source Code POV

The Overture code base is grouped in two main sets of (Maven) modules:

• Core Modules implement and provide the various functionalities of the tool
• IDE Modules are responsible for the User Interface and are heavily based on [Eclipse] 2 plug-ins.

In theory this should enforce strong separation of concerns --- the Core modules implement functionality and the IDE Modules implement the user interface. However, there are a few quirks worth mentioning. The IDE modules are all based on Eclipse and built with [Tycho] 1 so the set of IDE modules does not implement all user interfaces. It only implements the IDE version. On the other hand, some of the IDE Modules implement functionalities that are not available in the Core set (examples include uml2 and latex). More details can be found in the module overviews.

There are some advantages to the code into functionality modules and IDE modules. Namely the fact that most of the actual functionalities of Overture are detached from Eclipse. Therefore, should we ever decide to change the IDE support, migration will be easier.

In general, the development of new functionalities for Overture should follow this pattern: implement the actual functionality in a core module and implement its user interface in the form of an Eclipse Plug-in that provides access to the core module. Any external dependencies of a plug-in should be manged through Maven. If that is not possible due to, for example, Eclipse dependencies that cannot be built with Maven, then the module cannot go in the core set.

Functionality POV

In terms of functionality, Overture can be split into core functionalities and plug-ins (keep in mind that this is not the same as the core and IDE module sets). The core functionality is implemented by the parser, type checker and AST. The parser and type checker construct and validate an AST that represents the VDM model being worked on. These 3 modules are considered the core because they do not make sense on their own. Every functionality in Overture requires a valid AST to work and these 3 modules are responsible for providing it.

Every other functionality in Overture is conceptually viewed as a plug-in or extension on top of this. This generally means that almost all modules depend on the AST. Most modules need not depend on the parser directly. You need the parser present to construct an AST but in general you should not need to declare the parser as a dependency. The type checker is a bit more subtle. In addition to validating the AST, it offers various utilities so it may be necessary. Consult the TC reference page when in doubt.

A note on terminology

From reading this page alone, you will have seen that there some terms (such as core, extension, plug-in, module) that are used with different meanings in different contexts. In most cases, the meaning should be clear from the context but it's something worth being aware of.