MetaPHOR Project Report: MetaEdit+ architecture

3.3. The MetaEdit+ environment

Computer Aided Systems/Software Engineering or CASE tools, much-heralded as the perfect answer to every software designer's problem, have largely failed to have the expected effects. Recent studies suggest that the main reason for this observed lack of success has been the narrowness of their approach, which forces the designer to use methodologies supplied as part of the package, rather than allowing him to use and evolve those with which he is already familiar. The response of the industry has been the so-called CASE shells, which allow the user to specify his own methodology or metamodel, and then to design with that. However, still more work is needed to support the full spectrum of methodologies.

The efforts to build method independence into CASE shells are proving successful, insofar as they allow independence from a particular method's graphical symbols, conceptual data, and rules for creating models. This should be extended still further to include full representational independence, so that the user can choose among several basic representational paradigms. Such an approach seems best served by having a multi-tool CASE shell, with each tool able to display the conceptual information in a given paradigm -- including graphical diagram, matrix, free-form text, form-based text and hypertext -- and where new tools can be added. Only by doing this can the methods be specified from a computer engineering viewpoint. Moreover, only representational independence allows us to improve the intelligence provided for designers to use different representational paradigms to support different intellectual activities on the same model.

MetaEdit+ is a multi-user, multi-tool, meta-CASE environment under development in the MetaPHOR project. It is based on the earlier MetaEdit, which used the four concepts of the OPRR model (described later) to model methods, and also as the underlying data model for the design diagrams themselves. For MetaEdit+, the OPRR model has been extended to GOPRR, by the concept of Graph, corresponding to a single diagram in other CASE tools, and by allowing objects to have a recursive structure. This conceptual model forms the basis on which varied representations of data, including not only the usual graphical diagrams but also hypertext, text and matrices, are built. This allows the application to support a wider range of existing methodologies, and also allows customisation closer to the in-house methodology of any given organisation. Moreover, it improves the representational independence of the method support.

Together, these features provide a substantial improvement to the support offered by metaCASE tools for design, and in particular for the process of designing IS functionality.

3.3.1. Architecture

The basic architecture of MetaEdit+ is illustrated in Figure 1. The heart of the environment is the MetaEngine, which handles all operations on the underlying conceptual data. This allows the flexible addition of new tools, each only responsible for its own paradigmatically different view on the same underlying data, thus introducing representation independence. A tool, as the term is used within the MetaPHOR project, is a type of window with associated functionality, through which a user can view and possibly alter a design in a particular way.

At any one time, an organisation has several simultaneous ISD projects. Because each project may have its own specific features, the projects usually need individually-tailored methodologies and tools to support these. Yet, individual users of tools may participate in several development projects. Moreover, each project, in principle, uses only one specific methodology. These are the basic assumptions behind the development of the functionality of MetaEdit+.

MetaEdit+ can run either as a single-user workstation environment, or simultaneously on many workstation clients connected by a network to a server. Each client has a running instance of MetaEdit+, including all its tools and the MetaEngine, which takes care of all issues involved in communicating with the server. At the server is a repository holding all the data contained in models, and also metamodel, user and locking information.

Various tools communicate with each other through the MetaEngine, and through the shared data in the repository. These tools are:

the Work Space, which controls access to graphs and metamodels;
the various Metamodeling Tools, where methods and their components are defined;
the Draw Window, where graphical diagrams are edited;
the Matrix Editor, where graphs can be viewed and edited as matrices, and algorithms performed on them to aid the system design;
the Transformation tool, which produces textual descriptions of the entities stored in the repository;
the Query Editor, which allows the user to formulate graphical queries on the database;
the Repository Browser, which allows hierarchical access to any data stored in the repository;
the Hypertext subsystem, which gives the ability to add notes and links to any design element in any other tool.

In the rest of this subsection we will examine these various parts of the MetaEdit+ environment. First we will look at the GOPRR conceptual model, and the MetaEngine which implements it, and then at the various tools and support systems in the environment.

On to the next section about GOPRR.