John Grundy's Projects

Most of my research has focused on software tools and to a lesser extent software methodologies. I have also dabbled in user interfaces, design, component- and service-based systems and software architecture. Projects below are the more or less current ones and a few historical ones…

Marama

Domain-specific visual language tools have become important in many domains of software engineering and end user development. However building such tools is very challenging with a need for multiple views of information and multi-user support, the ability for users to change tool diagram and meta-model specifications while in use, and a need for an open architecture for tool integration. We have developed a meta-tool, Pounamu, aims to support users to rapidly design, prototype and evolve tools supporting a very wide range of visual notations and environments.

We have then developed Marama, a set of Eclipse plug-ins that realize domain-specific visual modelling tools specified using high-level DSVL tool specifications produced from the existing meta-tool, Pounamu. Marama allows users to rapidly specify or modify a desired visual language tool using Pounamu design tools and then have the tool realised as a high-quality Eclipse-based editing environment.

A set of Marama Meta Tools are being implemented to replace the Pounamu tool specifications, even though Pounamu specified tools are still loadable and functioning in the Marama environment. Now Marama integrates the features of both meta-tools and modelling tools. Marama uses Marama Metamodel Definer view to specify tool metamodel, Marama Shape Designer view to specify tool shapes and connectors, Marama ViewType Definer view to specify mappings of meta-elements to visual representations, and Marama Diagram view to create model instances or independent views of selected view type.

More details and downloads here.

Much of our current work with Marama focuses on using the tools (see below) and extending the meta-tools in areas such as:

        thin-client (web browser and mobile phone)-based diagram editing

        collaborative work support for both Eclipse-based and thin-client based diagram editors

        critic design meta-tool for richer user feedback

        integrated complex data mapping for import/export, code generation

        visual languages for declarative behaviour specification

        higher order functions for OCL-based constraints

        extending the initial sketching-based support for drawing diagrams with stylus e.g. on TabletPC

Marama-built Tools

We have built many tools with Marama. Some examples include:

  • MaramaMTE – performance engineering
  • MaramaEML – business process (enterprise) modelling
  • MaramaVMLPlus – complex data mapping
  • Various UML and other software design tools

 

We are developing a wide variety of new Marama tools and often have undergraduate and graduate classes use it for small projects. Examples of new tools include:

  • DSVLs for health care plan design and application generation
  • architecture engineering
  • critic designer
  • business process designer
  • social networking and knowledge management tools
  • visual wikis

Pounamu

Pounamu was a Java-based, stand-alone design tool for building domain-specific visual language tools. It provided a number of facilities for designing DSVLs including a meta-model designer, shape designer, view type designer and event handler designer. We built many tools with Pounamu including software design, architectural design, circuit design, process modelling, project management, traits modelling and statistical survey modelling. We extended Pounamu in various ways to support rich collaborative work, thin-client and mobile device diagramming and full web services-based API. Pounamu has now been retired and superseded by Marama.

 

More details and downloads here.

Aspect-oriented Component & Service Engineering

I have been developing a methodology and support tools for "aspect-oriented" component - and more recently service - engineering. This uses the concept of "aspects" of an overall component-based application that each component contributes to ("provides" functionality for) or needs from other components ("requires" functionality). In additional to aspects capturing a systemic perspective on the functional behaviour of components, they can be used to specify non-functional constraints e.g. performance, robustness, interfacing etc. I worked on several different parts of  aspect-oriented component/service engineering, including:

  • aspect-oriented requirements engineering: at the requirements level, aspects allow component and system developers to capture and reason with high-level capabilities of components, using various common aspects like persistency, user interface, configuration, distribution, collaborative work, inter-component relationship etc. It also allows developers to define and use their own "aspects", perhaps domain and/or application-specific. Aspects aid the specification and reasoning about component requirements, and also help support global component requirements specification and requirements evolution.
  • aspect-oriented software component design: refinement of aspect-oriented component requirements into software component design-level aspects is natural and aids software component design and validation. Refinement normally involves making various trade-offs and choices about component inter-relationship and particular aspect implementation techniques.
  • component implementation and run-time use of aspects: aspect information can be used to guide component implementation, specifically the design of highly generic and reusable component interfaces. It can also be encoded into components for run-time use by other components and end users. We experimented with automated test synthesis from these aspects for EJBs.
  • a range of tool support using JComposer and Pounamu meta-tools including component repository, visual languages for component composition, service modelling tools and code generation

Adaptive User Interfaces

We have developed a strong interest in supporting "adaptive" user interfaces from several perspectives. This includes allowing component-based systems to adapt the UIs of existing components as new components are plugged in; the adaptation of UIs to different contexts, users, user tasks and domains; and the support of thin-client user interface infrastructures and tools. More recently we’ve looked at thin-client diagramming for Pounamu and Marama meta-tools – generating mobile and web-based diagramming tools – as well as generating interfaces from high-level UI descriptions with Marama-based tools for the healthcare domain.

MViews, JViews & JComposer

Many years ago I developed MViews, a framework for building such ISDEs. MViews is both a model and reusable OO framework of Snart (OO Prolog!) classes for building new multi-view editing environments. It supported very flexible view consistency mechanisms, and also generic undo/redo facilities, attribute recalculation schemes, tool integration and extension mechanisms, and a common UI look-and-feel for all tools. I extended MViews to support asynchronous, semi-synchronous and synchronous editing facilities for collaborative software development. This included version control support, semi-synchronous change broadcasting and display, and synchronous fine-grained locking of view components.

 

JViews was a Java-based "port" of MViews, though with many enhancements and new abstractions. JViews is a specialisation of the JavaBeans API which supports componentware development. JViews provides many additional consistency management facilities, as well as the BuildByWire tool for flexible user interface construction. While JViews is a port of the old Snart-based MViews, it also incorporates many new abstractions not supported in the old MViews. These include a new mechanism for distributed object management, broadcasting of components and change descriptions (events) between multiple, distributed users' machines etc.

JComposer provides a visual language for specifying JViews-based tools, and generates JViews (i.e. Java beans-based) implementations of these tools. Users specify repository and view meta-models and a variety of event handling mechanisms with JComposer, generate JViews implementations of these tool specfications, and then may extend these generated classes via extension to add more custom/complex code to their applications.

JVisualise is a run-time visualisation tool for examining and reconfiguring JViews-based tools. It utilises similar graphical languages to JComposer.

The BuildByWire interactive icon and editor specification tool, developed by Rick Mugridge, is used to provide a Java Beans and Swing based interface to JComposer/JViews environments.

MViews, JViews and JComposer have all long been retired and superseded by Marama.

 


If you're interested in any of these projects, you can contact me at the address below.

Back to John Grundy's Home Page...

Professor John Grundy
Department of Computer Science
University of Auckland
Private Bag 92019
Auckland
New Zealand
 
WWW:    http://www.cs.auckland.ac.nz/~john-g

John Grundy (john-g@cs.auckland.ac.nz). Last updated: 27th July 2007