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…
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
We have built many tools with Marama. Some examples include:
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:
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.
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:
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.
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.
Department of Computer Science
Private Bag 92019
Auckland New Zealand