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.
Back
to
Professor John Grundy Department of Computer Science