Translation between models/programs

As well as user to computer translation, an important area of research is similar semi-automated translation between computer programs and models. Much of the structure of programs/models is the same regardless of what particular programming language is used. Making translations of a program/model available on multiple systems by translation from one to the other eases maintenance and re-use and widens availability. Also involving users in such a process would enable sharing and understanding of models/programs, so aiding Decision Support.

User Driven Modelling Explanation - Cube

This example was provided to illustrate the structure and process for creating the ontology, model, and visualisation/representation used for translation process from step 1 to step 3, for the User Driven Modelling approach. This also helps to demonstrate how the research provides a solution for generic and reusable engineering modelling, by providing a real but simple demonstration of this modelling approach being used for an engineering model.

The cube model, as for all the engineering/process models is made up of the definition, in this case of the cube, and a colour coded representation of all the processes, materials, tooling, consumables, resources, and rates used for the manufacture of the cube; these are read in from the ontology in response to user choices. This makes it possible to investigate scenarios such as in this case whether to manufacture using welding, or riveting, and different options for use of tooling, consumables, resources, and rates. From investigating different options, different trees are created to represent different paths/options, and from this the production cost tree is created with results and feedback on exactly what made up the process/cost. Figure 1 illustrates how the different sub ontologies/taxonomies are colour coded in order to ensure it is easier to read the meaning of the tree and the interrelationships between the different aspects of the model.



Figure 1 Cube model example - illustrates choice of process etc.

In this example, aluminium was chosen as the material, and riveting was chosen as the process. This example also illustrates how the Vanguard System modelling tool automatically combines units appropriately.

Figure 2 shows the cube translated and visualised using SVG (Scalable Vector Graphics).

Figure 2. Translation to SVG Visualisation
This shows the interactive version of the diagram that works in Internet Explorer using the Adobe SVG viewer 3 http://www.cems.uwe.ac.uk/~phale/SVGCubeExample/CubePartDefinitionwithCosts.htm - SVG Viewer download - http://www.adobe.com/svg/viewer/install/.

Next the implementation of this research was illustrated with the more complex example of an aircraft wingbox, using the same approach.

User Driven Modelling Explanation - Cube

Following on from the previous simpleast example of a rectangle, this example is of a cube, and includes manufacturing process information in the model.

This example is provided to illustrate the structure and process for creating the ontology, model, and visualisation/representation used for this 3 step translation process.

The cube model, as for all the engineering/process models is made up of the definition of the cube, and a colour coded representation of all the processes, materials, tooling, consumables, resources, and rates used for the manufacture of the cube; these are read in from the ontology in response to user choices. This makes it possible to investigate scenarios such as in this case whether to manufacture using welding, or riveting, and different options for use of tooling, consumables, resources, and rates. From investigating different options, different trees are created to represent different paths/options, and from this the production cost tree is created with results and feedback on exactly what made up the process/cost. Figure 1 illustrates how the different sub ontologies/taxonomies are colour coded in order to ensure it is easier to read the meaning of the tree and the interrelationships between the different aspects of the model.



Figure 1. Cube model example - Illustrates choice of process etc.

In this example, aluminium was chosen as the material, and riveting was chosen as the process. This example also illustrates how the Vanguard System modelling tool automatically combines units appropriately. Figure 2 shows the cube translated and visualised using SVG (Scalable Vector Graphics).

Figure 2. Translation to SVG Visualisation

This shows the interactive version of the diagram that works in Internet Explorer using the Adobe SVG viewer 3 http://www.cems.uwe.ac.uk/~phale/SVGCubeExample/CubePartDefinitionwithCosts.htm - SVG Viewer download - http://www.adobe.com/svg/viewer/install/.

Decision Support Tool Representation

It's important to close the gap between ontology representation and modelling and visualisation of problems. There is much more incentive to poulate an ontology or database if the information in this is automatically or semi automatically translated for use in modelling and decision support. Then those populating an ontology can see the benefits, and those creating or using models/programs based on the ontology can see where the inforamation is coming from.

Equations/formulae can be represented in the ontology, and then sent to the model which can then visualise them and calculate results. A Decision support tool called Vanguard System was used for this.

This screenshot illustrates how a decision support system tree view of the spar (wing part)branch from a wing process and cost model can be created with information translated from an ontology (in Protege) of related taxonomies (sub ontologies), and where necessary from user's selections (e.g. of materials). The tree, including all the default part definition information for the spar, is produced automatically. The buttons in the tree enable choices to be made by the user about materials, consumables, rates, and processes. Branches are created in response to these choices. The values in the branch nodes can then be changed as required.
Results can also then be output to the web for navigation and visualisation, and maybe for interactive web based modelling and visualisation.

Systems Enginering and Simulation

The intention of this project is to create a way for non programmers to create software in high level open standards based declarative languages built with Semantic Web technologies. The reasoning behind this is that if Semantic Web languages can represent data, they can also represent programs, as programs are just a specialised kind of data. The non programmer would program with this declarative language by means of a diagrammatic visualisation.

Many people would like to make greater use of computer technology but are hampered by the need to learn programming languages if they are to fully interact with software. Instead they are limited to the use of certain generic features that are provided for them. A further constraint is the cost of software, and for this project we will develop free software and encourage a community of end-user developers, and modellers.

We aim to provide Semantic Web based modelling and simulation tools that are usable and programmable by end-users. This is in order to ease the difficulties involved in translating requirements between software experts and domain experts. Our research will develop, extend, and combine existing research in provision of web page development tools for end-users, meta-programming, and web based modelling and simulation tools. The diagram below explains the research area we intend to explore.

This research will be part of co-ordinated efforts to enable end-user programming for knowledge management (including e-learning), modelling and decision support, and simulation. Therefore the research will concentrate mainly on translation for simulation and enabling non programmers to create web-based simulation systems. This is illustrated in the figure below.

The main research area will be the interface between Meta-Programming, Modelling and Simulation, and Semantic Web Model Creation, shaded in the figure below. This could allow end-users to develop their own Semantic Web based simulation and modelling tools using a graphical visual interface.

A simple illustration of the techniques that can be used to further this research area is a demonstrator we completed for meta-programming of XML (eXtensible Markup Language) based drag and drop trees. Python is used as a translator between the XML representation of the trees and interactive graphical representations of them. This allows open standards platform independent end-user programming. Such techniques could be used with other Semantic Web based information representations based on languages and structures such as XML, RDF (Resource Description Framework), and OWL (Web Ontology Language), and provision of other controls. These could then be used as graphical components of a simulation system made available over the web. This demonstrator furthered the research of Anderson and Krause [1]. Whiteside also used XML based meta programming to allow end user programming of games with Simkin [2]. Semantic languages provide a higher level declarative view of the problem to be modelled.

Standardisation in XML/RDF enables use of declarative rules for web services. Rules play an important role in artificial intelligence, knowledge-based systems, and for intelligent agents. To allow information sharing and reuse, interoperability, and collaboration an ontology centric approach can be used [3]. Ontologies are defined by Gruber in [4], and he also examines how equations and quantities can be represented in an ontology. Extending such work can enable functions and calculations to be represented in OWL and called by a Semantic Web based programming language.

References

[1] Sample code using drag & Drop with a tree - http://lists.wxwidgets.org/archive/wxPython-users/msg11332.html - Drag and Drop contributed by Sam Anderson, reposted by Dirk Krause.

[2] Simkin - http://www.simkin.co.uk/Links.shtml.

[3] COSMOA: An Ontology-Centric Multi-Agent System For Coordinating Medical Responses To Large-Scale Disasters. Bloodsworth, P., Greenwood, S., 2005. AI Communications Vol 18 (3) Agents Applied in Health Care pp 229-240.

[4] Toward Principles for the Design of Ontologies Used for Knowledge Sharing - Gruber T. R. 1993, http://www2.umassd.edu/SWAgents/agentdocs/stanford/onto-design.pdf - In Formal Ontology in Conceptual Analysis and Knowledge Representation, edited by Nicola Guarino and Roberto Poli, Kluwer Academic Publishers, in press. Substantial revision of paper presented at the International Workshop on Formal Ontology, March, 1993, Padova, Italy. Available as Technical Report KSL 93-04, Knowledge Systems Laboratory, Stanford University.

Other Pages on this subject

http://www.cems.uwe.ac.uk/amrc/seeds/ModellingSemanticWeb.htm.

http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/RDF/RDF.htm.

http://www.cems.uwe.ac.uk/amrc/seeds/softwareengineering.htm.

User Driven Modelling - Detailed Explanation - Part 4 - Translation

For this research the focus is on combining the development of dynamic software created in response to user actions, with object oriented, rule based and semantic web techniques. This helps solve problems of mismatch of data between object oriented and relational database systems identified by Ambler [1]. The information is highly structured. Visualisation of this structure in order to represent the relationship between things clarifies the semantics. The meaning can be seen not just by the name of each item but also by the relationship of other items to it. It is envisaged that this taxonomy will provide a design costing capability, but the taxonomy and the techniques used to put it together could be re-used for other purposes. Eventually this taxonomy could become part of an overall ontology. At first this would be a light-weight ontology and this could be evaluated for usefulness before deciding on whether it would need to be more structured. Hunter [2] evaluates engineering ontologies and gives examples. Issues involved in visualisation of light weight ontologies are examined by Fluit et al. [3]. An important reason for creation of an open standards central ontology is that it can be accessed by many different applications. The open standard OWL (Web Ontology Language) is explained by Bechhofer and Carroll [4]. Research of others in this field have been investigated Corcho and Gómez-Pérez [5] and Corcho et al. [6], Noy [7].

The approach involves adapting or creating software systems to provide the visual editor for the source tree, and model builders would create a model by editing this. By doing so they would create a generic model for a particular modelling subject. This is enabled by provision of translation software to translate the taxonomy into a decision support and modelling system. The model users could then use this decision support and modelling system to create their models. These models are a more specific subset of the generic model, and could be applied for their own analyses. Current research is on provision of a translation mechanism to convert information or models into other languages (primarily web based), and to visualise this information. This mechanism has been used in projects with two major aerospace companies. Examples of this are shown later in the article.

The alternative approach involves creation of an elaborator that can output code, in various computer languages or a Meta-programming syntax such as metaL [8] or Simkin [9]. The elaborator needs only a few pieces of information. All information other than that dependant on user interaction, including the names of each node and its relationships to other nodes, needs to be held in a standardised data structure, e.g. a database or structured text file(s). A visual interface to this ontology is required so that model builders can maintain and extend it.
Each node (elaborator) needs to be provided with the following pieces of information -

1) A trigger sent as a result of user action. This is a variable containing a list of value(s) dependant on decisions or requests made by the user the last time the user took action. Each time the user makes a request or a decision, this causes the production of a tree or branch to represent this. This trigger variable is passed around the tree or branch as it is created. The interface to enable this is connected to and reads from the ontology.

2) Knowledge of the relationship between this node and its' immediate siblings e.g. parents, children, attributes. So the elaborator knows which other elaborators to send information to, or receive from.

3) Ability to read equations. These would be mathematical descriptions of a calculation that contains terms that are items in the ontology. The equation would be contained within an attribute of a class, e.g. The class Material Cost would have an attribute Material Cost Calculation that holds an equation.

4) Basic rules of syntax for the language of the code to be output.
The way the elaborator finds the information held in 2 and 3 is dependent on the action that is taken in 1. Thus, if a suitable ontology is created the basis of the rules of construction of the code to be created are defined 4, and the user has made choices, the user needs to take no further action and just wait for the necessary code to be output.

The translation mechanism is illustrated on my web site http://www.cems.uwe.ac.uk/~phale/ using a simple example - http://www.cems.uwe.ac.uk/~phale/RectangleDemo/RectangleDemo.viewlet/RectangleDemo_launcher.html.

References

1 Ambler, S. W. (2003). The Object-Relational Impedance Mismatch, http://www.agiledata.org/essays/impedanceMismatch.html.
2 Hunter, A. (2002). Engineering Ontologies, http://www.cs.ucl.ac.uk/staff/a.hunter/tradepress/eng.html.
3 Fluit, C., Marta S., Harmelen F. V. (2003). Supporting User Tasks through Visualisation of Light-weight Ontologies, http://www.cs.vu.nl/~frankh/abstracts/OntoHandbook03Viz.html.
4 Bechhofer, S. and Carrol, J. (2004). Parsing owl dl: trees or triples?, Proceedings of the 13th international conference on World Wide Web, NY, USA: 266 - 275.
5 Corcho, O. and Gómez-Pérez, A. (2000). A Roadmap to Ontology Specification Languages, Proceedings of the 12th International Conference on Knowledge Engineering and Knowledge Management, Chicago, USA.
6 Corcho, O., Fernández-López, M., Gómez-Pérez, A. (2003). Methodologies, Tools and Languages For Building Ontologies. Where is their Meeting Point?, Data and Knowledge Engineering, 46: 41-64.
7 Noy, N.F. (2004). Semantic Integration: A Survey Of Ontology-Based Approaches. SIGMOD Record, Special Issue on Semantic Integration, 33 (4).
8 Lemos, M. (2006). MetaL: An XML based Meta-Programming language, http://www.meta-language.net/.
9 Simkin. (2006). A high-level lightweight embeddable scripting language which works with Java or C++ and XML, http://www.simkin.co.uk/.

User Driven Modelling - Detailed Explanation - Part 3 - Criteria Necessary

Why a different approach is needed

Translating concepts into an implementation is difficult. The difficulty of trying to explain the subjects of interest in a call for papers, or proposals illustrates this problem. Because of the ambiguity of words, there is always going to be a problem of interpretation between those who specify the requirements, and those who need to understand and interpret them.

For software development, a good way to reduce the level of misunderstandings is to go through the loop from concept to design to implementation quickly and efficiently so that feedback can be returned from the software model. Then mistakes can be seen and corrected quickly. It becomes much easier to achieve this high speed development, if the interface for development is made sufficiently easy to understand, so that a domain expert can use it to create the software, or at least a simple prototype that a developer can then work with and improve. Even if the aim of the users is to specify requirements rather than create programs, creating working programs conveys requirements much better than any other form of requirement specification.

It may also prove possible to work in reverse from implementation to design, or design to conceptual model. A UWE paper explains how ontologies could be mapped to conceptual models, El-Ghalayini Et al. [1]. This process can be made easier if the same open standard software representations, languages, and structures are used throughout this process. This would be useful for checking software is designed well or re-using software designs.

User involvement is important in the development of software but a domain expert does not necessarily possess expertise in software development, and a software developer cannot have expertise in every domain to which software might apply. So it is important to make it possible for software to be created using methods as close as possible to that which the domain expert normally uses. The proportion of domain experts in a particular domain (aerospace engineering) for example who can develop their own programs is fairly low, but the proportion that are computer literate in the everyday use of computers is much higher. If this computer literacy is harnessed to allow the domain experts to develop and share models, the productivity for software development will be increased and the proportion of misunderstandings between domain experts and developers reduced. The domain experts can then explore a problem they are trying to solve and produce code to solve it. The role of developers would then become more that of a mentor and enabler rather than someone who has to translate all the ideas of experts into code themselves. Other developers may work at providing better translation software for the experts.

User Driven Model Development

The intention of the research into User Driven Modelling (UDM) and more widely User Driven Programming (UDP) is to enable non-programmers to create software, from a user interface that allows them to model a particular problem or scenario. This involves a user entering information visually in the form of a tree diagram. The research involves developing ways of automatically translating this information into program code in a variety of computer languages. This is very important and useful for many employees that have insufficient time to learn programming languages. To achieve this, visual editors are used to create and edit taxonomies to be translated into code. To make this possible, it is also important to examine visualisation, and visualisation techniques to create a human computer interface that allows non-experts to create software.

The research mainly concentrates on using the above technique for modelling, searching and sorting. The technique should be usable for other types of program development. Research relevant to User Driven Programming in general is covered, as this could be applied to the problem in future.

This research unites approaches of object orientation, the semantic web, relational databases, and event driven programming. Tim Berners-Lee defined the semantic web as 'a web of data that can be processed directly or indirectly by machines' [2]. The research examines ways of structuring information, and enabling processing and searching of the information to provide a modelling capability.

UDM could help increase user involvement in software, by providing templates to enable non-programmers to develop modelling software for the purposes that interest them. If more users of software are involved in creation of software and the source of the code is open, this allows for the creation of development communities that can share ideas and code and learn form each other. These communities could include both software experts, and domain experts who would be much more able to attain the expertise to develop their own models than they are using current software languages.

Criteria necessary for User Driven Model Development

This section explains the theory behind the User Driven Modelling approach, and the factors necessary to make this approach possible. For this research the focus is on combining the development of dynamic software created in response to user actions, with object oriented, rule based and semantic web techniques. Research has examined ways of structuring information, processing and searching this information to provide a modelling capability. Research by Aziz et al. [1] examines how open standards software can assist in an organisations collaborative product development, and Wang et al. [2] outline an approach for integrating distributed relational database systems. Our automated production of software containing recursive Structured Query Language (SQL) queries enables this. This approach is a type of very high level Meta-programming. Meta-programming, and structured language is explained by Dmitriev [3] and Mens et al. [4]. The approach proposed is intended to solve the problems of cost and time over-run, and failure to achieve objectives that are the common malaise of software development projects. The creation of a web based visual representation of the information will allow people to examine and agree on information structures.

Firstly it is necessary to find a way for people with little programming expertise, to use an alternative form of software creation, that can later be translated into program code. The main approach taken was the use of visual metaphors to enable this creation process, although others may investigate a natural language approach. The decision on what combination of diagrammatic or natural language to use in the representation may be influenced by the type of user and the domain to be modelled. Engineers usually deal with diagrams as a regular part of their work, so understand this representation particularly well. In fact developers also use metaphors from engineering diagrams in order to provide a user interface for software design. This is explained in Tollis [5].

A translation method can then be provided that converts this representation into program code in a number of languages, or into a Meta-language that can then be further translated. In order to achieve this, it is necessary for the translator to understand and interpret equations that relate objects in the visual definition and obtain the results. In order for the user to understand the translation that has been performed it is then important to visualise the translated code, and this must be accessible to others who use the translated implementation. Web pages are a useful mechanism for this as they are widely accessible.

This visualisation of results is essential to express clearly their meaning. Words in a report document can be ambiguous. So the relationship of results to inputs must be clearly shown.

References

1 El-Ghalayini, H., Odeh, M., McClatchey, R., Solomonides, T. (2005). Reverse engineering ontology to conceptual data models, http://www.uwe.ac.uk/cems/graduateschool/news/posters/conference/conference2005.pdf, Graduate School Conference, 114-119.

2 Berners-Lee, T. (1999). Weaving the Web, Orion business - now Texere, http://www.w3.org/People/Berners-Lee/Weaving/Overview.html.

3 Aziz, H., Gao, J., Maropoulos, P., Cheung, W. M. (2005). Open standard, open source and peer-to-peer tools and methods for collaborative product development, Computers in Industry, 56: 260-271.

4 Wang, C.-B., Chen, T.-Y., Chen, Y.-M., Chu, H.-C. (2005). Design of a Meta Model for integrating enterprise systems, Computers in Industry, 56: 205-322.

5 Dmitriev, S. (2004). Language Oriented Programming: The Next Programming Paradigm, http://www.onboard.jetbrains.com/is1/articles/04/10/lop/.

6 Mens, K., Michiels, I., Wuyts, R. (2002). Supporting Software Development through Declaratively Codified Programming Patterns, Expert Systems with Applications, 23: 405-413.

7 Tollis, I. G. (1996). Graph Drawing and Information Visualization, ACM Computing Surveys, 28A(4).

My Home Page is at http://www.cems.uwe.ac.uk/~phale/.
More Information on End-User Programming research is at - http://www.cems.uwe.ac.uk/amrc/seeds/EndUserProgramming.htm.
More information on Semantic Web research is at - http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/RDF/RDF.htm.

User Driven Modelling - Detailed Explanation - Part 2 - Research Approach

This research demonstrates how a taxonomy can be used as the information source, from which it is possible to automatically produce software. This technique is most suitable at present to modelling, visualisation, and searching for information. The article explains the technique of User Driven Model (UDM) Development that could be part of a wider approach of User Driven Programming (UDP). This approach involves the creation of a visual environment for software development, where modelling programs can be created without the requirement of the model developer to learn programming languages. The theory behind this approach is explained, and also the main practical work in creation of this system. The basis of this approach is modelling of the software to be produced in Ontology systems such as Jena http://www.hpl.hp.com/semweb/ and Protege http://protege.stanford.edu/. It also has the potential to be computer language and system independent as one representation could be translated into many computer languages or Meta languages (will explaine in other articles).

The research applies this User Driven technique to aerospace engineering but it should be applicable to any subject. The basis of the research is the need to provide better ways for people to specify what they require from computer software using techniques that they understand, instead of needing to take the intermediate steps of either learning a computer language(s) or explaining their requirements to a software expert. These intermediate steps are expensive in terms of time, cost, and level of misunderstanding. If users can communicate intentions directly to the computer, they can receive quick feedback, and be able to adapt their techniques in a quick and agile way in response to this feedback.

A modelling environment needs to be created by software developers in order to allow users/model builders/domain experts to create their own models. This modelling environment could be created using an open standard language such as XML (eXtensible Markup Language). As the high level translation though this would depend on tools developed using lower level languages, this is why tools such as Protege and DecisioPro http://www.vanguardsw.com/are used. Vanguard are creating a modelling network where universities can share decision support models over a network [Vanguard 2006]. This tool was used because it was selected during a project to evaluate, and then use software to solve costing problems. We are creating a modelling network that will link to that of Vanguard http://www.cems.uwe.ac.uk/amrc/seeds/models.htm.

Until recently XML has been used to represent information but languages such as Java, C++, and Visual Basic have been used for the actual code. Semantic languages such as XML could be used in future for software development as well as information representation, as they provide a higher level declarative view of the problem.

A requirement of this research is that open standard semantic languages are used to represent information, to be used both as input and output of the model. These languages are based on XML. These same open standard languages can be used for developing the program code of models. It is proposed that software and information represented by the software, be separated but represented in the same open standard searchable way. Software and the information it manipulates are just information that has different uses, there is no reason why software must be represented differently represented differently from other information. So XML can be used both as the information input and output by the application, and for the definition of the model itself. The model can read or write information it represents, and the information can read from or write to the model. This recursion makes 'meta-programming' possible. Meta programming is writing of programs by other programs. The purpose of this is to provide a cascading series of layers that translate a relatively easy to use visual representation of a problem to be modelled, into code that can be run by present day compilers and interpreters. This is to make it easier for computer literate non-programmers to specify instructions to a computer, without learning and writing code in computer languages. To achieve this, any layer of software or information must be able to read the code or the information represented in any other. Code and information are only separated out as a matter of design choice to aid human comprehension, they can be represented in the same way using the same kinds of open standard languages.

Dynamic software systems such as outlined by Huhns [1]. Huhns explained that current techniques are inadequate, and outlines a technique called Interaction-Oriented Software Development, concluding that there should be a direct association between users and software, so that they can create programs, in the same way as web pages are created today. Paternò [2] explains research that identifies abstraction levels for a software system. These levels are task and object model, abstract user interface, concrete user interface, and final user interface. Stages take development through to a user interface that consists of interaction objects. This approach can be used for automating the design of the user interface and the production of the underlying software. Paternò states that 'One fundamental challenge for the coming years is to develop environments that allow people without a particular background in programming to develop their own applications'. Paternò goes on to explain that 'Natural development implies that people should be able to work through familiar and immediately understandable representations that allow them to easily express relevant concepts'.

The methods used for this representation and translation will be explained in the rest of this document.

References
1 Huhns, M. (2001). Interaction-Oriented Software Development. International Journal of Software Engineering and Knowledge Engineering, 11: 259-279.

2 Paternò, F. (2005). Model-based tools for pervasive usability. Interacting with Computers, 17(3): 291-315.



My Home Page is www.cems.uwe.ac.uk/~phale/.

User Driven Modelling - Detailed Explanation - Part 1 - Research Aim

This research arises out of projects to create systems to facilitate management of design and cost related knowledge within aerospace organisations, with the aim of using this knowledge to reduce the costs of designing and manufacturing products. This paper identifies ways that problems arising from the model development process can be addressed, by a new way of providing for the creation of software. We have gained experience from projects, which have used a combination of proprietary software solutions and bespoke software. It is possible to identify the approach of User Driven Programming (UDP) as an effective software development technique. This research unites approaches of Object Orientation, the Semantic Web, and Relational Databases and Event Driven programming. The approach encourages much greater user involvement in software development. The advantages of increasing user involvement in software development are explained by Olsson [1]. The intention of this research is to allow users to create the whole model/program they develop without typing code.

User Driven Programming (UDP) and User Driven Modelling (UDM) are techniques of End-User Programming, http://www.cs.cmu.edu/~bam/papers/EUPchi2006overviewColor.pdf explains End User Programming. A diagram from this presentation illustrates how small a proportion of development is carried out by professional developers.

Categories of User
It is important to distinguish between the two different types of users for the system, as they would work on different parts of the overall system. However a person may be represented in either or both categories.

Model Builders
Model builders create or edit the semantic representation of the model in an ontology editor in order to create models. Model builders do not need knowledge of a programming language, but do need training in how to use the ontology interface to create a model, and some knowledge of the domain to which it is to be applied.

Model Users
Model users make decisions based on their domain knowledge. This type of user manipulates the tree representation to obtain a result based on the input values they know, or otherwise based on default values. They will want to be able to use a model to evaluate a problem in order to help in decision making.

Expertise of Users
Within this paper the terms user, and domain expert are used interchangeably. The user is a domain expert who wants a problem represented and modelled using software. The domain is engineering but our research could be applied to other domains. The users/domain experts may well be computer literate and able to model certain problems using a software tool such as a spreadsheet. For reasons that will be explained later, this is only sufficient for simpler problems. The reasons that spreadsheets should not be used to represent complex models are connected with difficulties in maintaining, extending, and reusing spreadsheet models. This might not be such a problem in future if research such as that of Oregon State and Houston Universities can succeed in automatically generating correct spreadsheets, and solving errors of meaning (semantic errors) [2].

For now, to be able to model a complex problem, the users/domain experts currently must specify their requirements to other software experts, who may or may not have domain knowledge themselves. It is difficult to find and afford those who have sufficient expertise in both the software and the domain. Someone without the domain knowledge may not understand the requirements. Putting the right team together is a difficult balancing act, and sometimes may be difficult or impossible.

Software development is time consuming and error prone because of the need to learn computer languages. If people could instruct a computer without this requirement they could concentrate all their effort on the problem to be solved. This is termed User Driven Programming (UDP) within this paper, and for the examples demonstrated the term User Driven Modelling (UDM) is used to explain the application of User Driven Programming to model development. This research aims to create software that enables people to program using visual metaphors. Users enter information in a diagram, which for these examples is tree based. Tree based visualisation is often a good way of representing information structures and/or program code structures. The software developed as part of this research translates this human readable representation into computer languages. The tree also shows the flow of information. This technique is a kind of End User Programming, research in this area is undertaken by the EUSES (End Users Shaping Effective Software) research collaboration [3].
Our research is explained with examples at www.cems.uwe.ac.uk/~phale/.

References
1 Olsson, E. (2004). What active users and designers contribute in the design process, Interacting with Computers, 16: 377-401.
2 Stanford University. (2006). Stanford University - Welcome to protégé, protege.stanford.edu/.
3 EUSES. (2006). End Users Shaping Effective

Collaborative Web Based Modelling

The SEEDS (Systems Engineering Estimation and Decision Support) team within AMRC (Aerospace Manufacturing Research Centre) is involved in modelling problems and visualising solutions in order to help with decision support. Vanguard Software has donated UWE (University of the West of England) a free server version of their decision support tool Vanguard Studio. This makes UWE part of a collaborative network of universities and industry that can create models and link them via a Wiki (editable website).

For my PhD research in User Driven Programming, I have been investigating ways of making it possible for users to program software without having to write code. This relies on visualisation of the problem in a similar way to modelling. So to make this approach possible I'm looking to develop free models and modelling tools for use over the Web. These can be used for teaching, collaborative problem solving, management decision making, and environmental modelling. The techniques used to build these models are often called Semantic Web or Web 2.0. This involves providing the kind of software over the Web that is already available on individual computers, and using this for sharing of information worldwide. I'm publishing these models online and linking Vanguard Studio with my own software to produce interactive models. These models change in response to the user, perform calculations, and range from dynamic computer aided design (CAD) type representations to hierarchical information explorers.

Example models are at :-

http://www.cems.uwe.ac.uk/~phale/Flash/FlashHCI.htm

http://www.cems.uwe.ac.uk/~phale/InteractiveSVGExamples.htm

http://wiki.vanguardsw.com/bin/browse.dsb?dir/Engineering/Aerospace/

Modelling and Decision Support using Web Technologies

Shim et al (2002) explain the importance of the web for all types of decision support activity "At the beginning of the 21st century, the Web is the center of activity in developing DSS." Shim et al explain how decision support systems can be provided at low cost and for geographically dispersed companies, customers and suppliers. They cite Power (2006b) when stating "Web-based DSS have reduced technological barriers and made it easier and less costly to make decision-relevant information and model-driven DSS available to managers and staff users in geographically distributed locations." This was the reasoning behind the DATUM (Design Analysis Tool for Unit-cost Modelling) project research (Scanlan et al, 2006). An open standards web driven method of collaboration is required to make it possible for organisations and individuals to become more deeply involved in projects that are well coordinated using web technologies. Shim et al explain how the use of web technologies to standardise user interface design across different models can dramatically improve the ease of use of decision support software. This standardisation can also ease problems of installation and maintenance.

(Morris et al, 2001) examine Interactivity and collaboration on the web. Aziz et al (2005) examine how open standards software can assist in an organisation's collaborative product development. This approach is outlined in (Ciancarini et al, 2001) that explains ways of designing a document-centric coordination application over the Internet. (Ciancarini et al. 2001) explain that web documents can be generated on the fly. This can allow the user interface to respond dynamically to choices. Program code can be attached to the documents themselves, and code can activate certain behaviour based on the XML (eXtensible Markup Language) content of the document. Code can also be created separately and called on as a service when a document needs it. (Nidamarthi et al (2001) explain how web based collaboration can aid the design process. (Huang and Mak, 2001) evaluate issues in the development and implementation of web applications for product design and manufacture. Reed et al (2000) show how web based modelling and simulation can be used in the aircraft design process. Kim et al (2002) explain their approach to modelling and simulation. Zhang et al (2004) review Internet-based product information sharing and visualisation. Li (2005) examines the role of web based services for distributed process planning optimization.

The intention is to further the research of others into the approach of web based collaboration, and use semantic web software and techniques to achieve this. The above research reinforced my view that this is a robust approach. Modelling collaborations based on these techniques would bring together experts in engineering, systems modelling, computing, and Human Computer Interaction.

More detail on this research can be found at - http://www.cems.uwe.ac.uk/amrc/seeds/ModellingSemanticWeb.htm

References

Shim, J.P., Warkentin, M., Courtney, J. F., Power, D J., 2002, Past, present, and future of decision support technology. Decision Support Systems 33 pp 111-126.

Power, D. J., 2006. Free Decision Support Systems Glossary - http://www.DSSResources.COM/glossary/.

Scanlan, J., Rao, A., Bru, C., Hale, P., Marsh, R., 2006. DATUM Project: Cost Estimating Environment for Support of Aerospace Design Decision Making. Journal of Aircraft, 43(4).

Morris, S., Neilson, I., Charlton, C., Little, J., 2001. Interactivity and collaboration on the WWW - is the 'WWW shell' sufficient?. Interacting with Computers, 13, pp 717-730.

Aziz, H., Gao, J., Maropoulos, P., Cheung, W. M., 2005. Open standard, open source and peer-to-peer tools and methods for collaborative product development. Computers in Industry, 56, pp 260-271.

Ciancarini, P., Rossi, D., Vitali, F. 2001. Designing a document-centric coordination application over the Internet. Interacting with Computers, 13, pp 677-693.

Nidamarthi, S., Allen, R. H., Ram, D. S., 2001. Observations from supplementing the traditional design process via Internet-based collaboration tools. Computer Integrated Manufacturing, 14(1), pp 95-107.

Huang, G. Q., Mak, K. L., 2001. Issues in the development and implementation of web applications for product design and manufacture. Computer Integrated Manufacturing, Vol 14(1), pp 125-135.

Reed, J. A., Follen, G. J., Afjeh, A. A., 2000. Improving the Aircraft Design Process Using Web-Based Modeling and Simulation. ACM Transactions on Modeling and Computer Simulation, 10(1), pp 58-83.

Kim, T., Lee, T., Fishwick, P., 2002. A Two Stage Modeling and Simulation Process for Web-Based Modeling and Simulation. ACM Transactions on Modeling and Computer Simulation, 12(3), 230-248.

Zhang, S., Weimen, S., Hamada, G., 2004. A review of Internet-based product information sharing and visualization. Computers in Industry, 54, pp 1-15.

Li, W. D., 2005. A Web-based service for distributed process planning optimization. Computers in Industry, 56, pp 272-288.

My Home Page is http://www.cems.uwe.ac.uk/~phale

I have a page for this subject at http://www.cems.uwe.ac.uk/amrc/seeds/ModellingSemanticWeb.htm

am a member of the Institute for End User Computing (IEUC) - http://www.ieuc.org/home.html