Related Research

In addition to the use of open standard ontology language it's also possible to use agreed semantics for the domain of engineering modelling. The language most relevant for this purpose is the Process Specification Language (PSL) of the National Institute of Standards and Technology (NIST). A representation of this PSL-XML [1] can be used with OWL, both OWL and PSL-XML are based on RDF-XML (Resource Description Framework) implemented with XML (eXtensible Markup Language). This makes our translation process simpler and can enable interaction with other systems.

Collaboration, simulation and modelling have been investigated to assist us in determining the requirements for future research in modelling of problems. Huhns [2] and Paternò [3] both explain that alternatives to the current approach to software development are required. This should allow translation from a model-based representation of software to the actual software. This could involve automatically producing software for a semantic web site from visual representations of the problem. The core of this modelling infrastructure would be automated generation of models written using World Wide Web Consortium (W3C) standards based languages and the visualisation of information represented in such W3C standard ways. We have examined modelling languages such as Alloy [4] Wallace [5], in order to establish how modelling languages can be used as an interface to an End-User Programming environment. Transformation from a model building environment to program code has been investigated by Gray et al [6]. MathML [7] can assist in this process by providing an open representation of functions as XML. Functions entered by the model developer can then be translated to this open representation and translated to programming languages and/or read by programming languages. The representation of functions and information can sometimes be illustrated diagrammatically. In the mid 1970s Smith [8] introduced the technique of Programming by Example with a program called Pygmalion, Smith elaborated on this in [9] (Chapter 1). This demonstrated the need to describe algorithms through concrete examples rather than abstractly. Guibert et al [10] explain and expands on Smiths work with an example demonstrating how numbers fail to reveal the concept behind them. The example is a numerical representation of a triangle. This representation is 'fregean' because it does not show the concept of a triangle. Next to this is a diagram of the triangle that does show the concept, this is referred to as 'analogical' representation because it includes the context of the information. Including the context of the information allows a person to discover meanings or relationships in the information which would not always be obvious. Semantic web languages allow for the context of the information to be represented in documents and so make it possible to represent information in an analogical way, as well as allowing the kind of two way interaction mentioned in section 2.1, leading to an improvement in information discovery. This is the theory behind our conversions to interactive SVG (Scalable Vector Graphics) and tree based representations of information and functions [11][12].
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. Morris et al. [13] examine Interactivity and collaboration on the web. Aziz et al. [14] examine how open standards software can assist in an organisation's collaborative product development. This approach is outlined in Ciancarini et al. [15] that explains ways of designing a document-centric coordination application over the Internet. Nidamarthi et al. [16] explain how web based collaboration can aid the design process. Huang and Mak [17] evaluate issues in the development and implementation of web applications for product design and manufacture. Reed et al. [18] show how web based modelling and simulation can be used in the aircraft design process. Kim et al. [19] explain their approach to modelling and simulation. Zhang et al. [20] review Internet-based product information sharing and visualisation. Li [21] 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 our 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.

[1] Lubell J, 2006 http://ats.nist.gov/psl/xml/process-descriptions.html - XML Representation of Process Descriptions
[2] Huhns, M. (2001) Interaction-Oriented Software Development, International Journal of Software Engineering and Knowledge Engineering, 11 259-279.
[3] Paternò, F. (2005) Model-based tools for pervasive usability. Interacting with Computers 17 (3), 291-315.
[4] Alloy http://alloy.mit.edu/ The Alloy Analyzer - 3.0 Beta
[5] Wallace C. (2003) Using Alloy in process modelling. Information and Software Technology, Vol. 45 (15), 1031-1043.
[6] Gray J, Zhang J, Lin Y, Roychoudhury S, Wu H, Sudarsan R, Gokhale A, Neema S, Shi F, and Bapty T, Model-Driven Program Transformation of a Large Avionics Framework, 2004, Third International Conference on Generative Programming and Component Engineering GPCE.
[7] W3C Math Home - http://www.w3.org/Math/Overview.html - What is MathML?
[8] Smith, D. C. (1977) A Computer Program to Model and Stimulate Creative Thought. Basel: Birkhauser.
[9] Guibert N, Girard P, Guittet L, (2004), Example-based Programming: a pertinent visual approach for learning to program, University of Poitiers, Proceedings of the working conference on Advanced visual interfaces - Pages: 358 - 361 - ISBN:1-58113-867-9.
[10] Cypher, A, 1993, Watch What I Do Programming by Demonstration, MIT Press, ISBN:0262032139.
[11] Hale P, http://www.cems.uwe.ac.uk/~phale/Flash/FlashHCI.htm - Spar - Tree based representation
[12] Hale P, http://www.cems.uwe.ac.uk/~phale/InteractiveSVGExamples.htm - Interactive Examples
[13] Morris, S., Neilson, I., Charlton, C., Little, J. (2001) Interactivity and collaboration on the WWW - is the 'WWW shell' sufficient?. Interacting with Computers, 13, 717-730.
[14] Aziz, H., Gao, J., Maropoulos, P., Chewing, W. M. (2005) Open standard, open source and peer-to-peer tools and methods for collaborative product development. Computers in Industry, 56, 260-271.
[15] Ciancarini, P. & Rossi, D. & Vitali, F. (2001) Designing a document-centric coordination application over the Internet. Interacting with Computers, 13 677-693.
[16] 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), 95-107.
[17] Huang, G. Q., Mak, K. L. (2001) Issues in the development and implementation of web applications for product design and manufacture. Computer Integrated Manufacturing, 14 (1), 125-135.
[18] 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), 58-83.
[19] Kim Y., Choi Y., Bong Yoo S. (2001) Brokering and 3D collaborative viewing of mechanical part models on the Web, Computer Integrated Manufacturing, 14 (1), 28-41.
[20] Zhang, S., Weimen, S., Hamada, G. (2004) A review of Internet-based product information sharing and visualization. Computers in Industry, 54, 1-15.
[21] Li, W. D. (2005) A Web-based service for distributed process planning optimization. Computers in Industry, 56, 272-288.

Aims and Future Work 2

The proposed project involves creation of an elaborator or translator that converts the diagrammatic representation of the problem into software. Translations can be performed into any programming or meta-programming language or open standard information representation language, the visualisation of the model created can displayed on the web.



Fig 1: Translation

The tool will enable users to build their taxonomy representation of the model from a library held in an open standard ontology. Flexibility is essential when different organisations are not all using the same systems. An important reason for creating the open standards ontology is that it can be accessed by many different users and/or applications. The open standard OWL (Web Ontology Language) will be used and is explained in [19].
Software that is been investigated for representing ontologies and translating to program code and visualisation is Stanford Univeristy's Protégé [20], Jena [21], Kaon [22]. Applications that are built with ontology tools such as the above and include a development environment for calculation and decision support are Metatomix m3t4 [23], TopBraid Composer [24], and General Electric's ACUITy enterprise modelling tool [25]. These tools include Java Eclipse extensions for high level programming. We have also investigated transformations that can translate the ontology into representations in other languages and tools. We have prototyped this translation for decision support tools DecisionPro [26] and Cost Estimator [27], and languages including XML (eXtensible Markup Language), and Java. XML has mainly been used as a neutral format for representing information, but its rich structure makes it suitable for use as a programming language e.g. AspectXML [28]. Further research can be undertaken into representing the information in meta languages such as metaL [29] and Simkin [30]. The result documents could be searched using XQuery within Exist [31] and SPARQL (Simple Protocol and RDF Query Language) [32] and edited using XForm editors such as Orbean XForms [33].
The elaborator needs to follow a structured taxonomy to establish how related concepts represented visually can be represented in equivalent code and vice versa. The visualisation can be either as a tree (that can be colour coded to represent different types of information) or as an interactive SVG (Scalable Vector Graphics) diagram of a component to be modelled. This example shows a tree based representation of an aircraft spar [34], this uses software by Rhodes et al. explained in [35]. This example [36] shows how a tree based representation is converted into an interactive diagrammatic representation, and explains how this transformation is performed.
Figure 2 shows a plan for weaving Aspect-Oriented Programming [37] into translation that are provided for end-user-computer communication. Aspect-Oriented Programming can be used where certain tasks or properties do not fall within a natural hierarchy. These are called Cross-Cutting Concerns [37], these Cross-Cutting Concerns could be tasks the program needs to perform such as providing printing or security. This same technique could also be used for attributes that the program is to model for example if the program is to model an aircraft wings, a user with sufficient computer literacy skills can model the representation of the wing as a hierarchical diagram. The user can specify relationships between these items that make it possible to make calculations and decisions. For this model some parameters such as efficiency, weight and cost might not fit well in this hierarchical representation. So the parameters could be weaved into the program as cross-cutting concerns in a similar way to the computing parameters.
Once all parameters are weaved into the program it can be translated from a format most suitable to visualisation and user interaction (e.g. OWL Web Ontology Language) to users into a computer language such as Java for implementation. The program would calculate results, and these could be translated back to the user. These results would be fed back in the language used for user interaction and visualisation. The results could be visualised using stylesheets and interactive software, and where useful translated further into other kinds of representations other than trees e.g. SVG (Scalable Vector Graphics) diagrams and graphs.



Fig 2: Translation and Aspect-Oriented Programming

Highly interactive web pages that act like programs to provide a user interface can be used to provide an interactive user driven programming environment. These interactive web pages could be modelled on Visual Programming Languages such as Alice [38] Interactive web programs can also be created using scripting languages and XML combinations such as AJAX (Asynchronous JavaScript And XML) is an overall name for techniques to create highly interactive web pages. Ajax techniques for creation of highly interactive web pages may assist computer literate end-users in programming tasks on the web [39].

References

[19] Bechhofer S., Carrol J. (2004) Parsing owl dl: trees or triples? Proceedings of the 13th international conference on World Wide Web, NY, USA pp 266 - 275.
[20] Protégé http://protege.stanford.edu/
[21] Jena http://jena.sourceforge.net/
[22] Kaon http://kaon.semanticweb.org/
[23] Metatomix m3t4 http://www.metatomix.com/news/060307.html
[24] TopBraid Composer http://www.topbraidcomposer.com/
[25] Aragones, A., Bruno, J., Crapo, A., Garbiras M. (2006) An Ontology-Based Architecture for Adaptive Work-Centered User Interface Technology. Jena User Conference 2006, Bristol, UK.
[26] DecisionPro http://www.vanguardsw.com/decisionpro/
[27] Koonce, D., Judd, R., Keyser, T., Bailey, M. A. (2000) Cost Estimation Tool Integrated into FIPER, American Institute of Aeronautics and Astronautics http://www.engineous.com/resources.htm
[28] AspectXML Project - http://www.aspectxml.org/
[29] MetaL http://www.meta-language.net/
[30] Simkin http://www.simkin.co.uk/Links.shtml
[31] Exist http://exist.sourceforge.net/
[32] SPARQL - http://dret.net/glossary/sparql - Simple Protocol and RDF Query Language
[33] Orbeon Xforms http://www.orbeon.com/
[34] Spar - Tree based representation http://www.cems.uwe.ac.uk/~phale/Flash/FlashHCI.htm
[35] Rhodes, G., Macdonald, J., Jokol, K., Prudence, P., Aylward, P., Shepherd, R., Yard, T., 2002. A Flash Family Tree, in: Flash MX Application and Interface Design Flash MX Application and Interface Design ISBN:1590591585 http://www.friendsofed.com/books/1590591585/
[36] Interactive Examples http://www.cems.uwe.ac.uk/~phale/InteractiveSVGExamples.htm
[37] Elrad, T., Filman, R. E., Bader, A., (2001) Aspect-oriented programming: Introduction. Communications of the ACM, 44, 10, 28-32.
[38] Alice http://www.alice.org/
[39] Cagle K, AJAX on the Enterprise, AJAXWorld conference, October 4, 2006 http://www.oreillynet.com/xml/blog/2006/10/ajax_on_the_enterprise.html

Aims - Future Work

The intention behind my work is to enable users to program integrated applications. It is intended that tools are created to enable users to develop software in a way familiar to many, from their use of spreadsheets and web page creation tools. End User Programming is an important area of research because many people who are experts in their domain want to create software models to aid their decision making [1]. Semantic Web Techniques can be used to assist non-programmers to create software. This software could allow interactive visual modelling of information. This corresponds to the type of work normally undertaken using spreadsheets. In order to model complex problems in spreadsheets it is necessary to use macro languages, and track relationships between values in cells. These can be difficult tasks, and mistakes lead to incorrect answers, this has led to a spreadsheet crisis where incorrect and undocumented spreadsheets are produced by individuals who have little formal training [2] [3]. It is essential to find alternative ways of representing these models, which do not require the user to write code. The software created must make it easy to interact with and change models, and easy to share information with colleagues. The main application areas of the tools would be Knowledge Management, Decision support, and Simulation. The system created could also be used to promote engineering to a sceptical public who see the profession as poorly paid and dirty, House of Lords Select Committee on Science and Technology report science and society [4].

The main aim of the research is User Driven Model Development. This research unites approaches of object orientation, the semantic web, relational databases, and event driven programming. [5] explain the opportunities for and importance of this kind of research. Tim Berners-Lee defined the semantic web as 'a web of data that can be processed directly or indirectly by machines' [6]. The research would examine ways of structuring information, and enabling processing and searching of the information to provide a modelling capability. Ways of increasing user involvement in software can be investigated, and the possibility of providing templates to enable non-programmers to develop modelling software for the purposes that interest them. The advantages of increasing user involvement in software development are explained by [7]. To assist in this, it is essential that new ways of enabling collaboration between all those involved in software creation and use are investigated.

This involves co-operation with the Institute for End User Computing (IEUC) [8]. Other End-User Programming Consortiums are End-Users Shaping Effective Software (EUSES) [9] and Network of Excellence on End User Development (EUD.Net) [10]. Program Transformation allows for writing in one representation or language, and translating to another. This is particularly useful for language independent programming, or for high level and End User Programming that can then be translated to a language more easily interpreted by computer systems. Techniques such as Generative Programming [11][12], Aspect Oriented Programming [13], Model Driven Programming [5][11] and Meta Programming and Language Oriented Progamming [14] are likely to be used to create the modelling environment for End Users.

Dissemination of research will be via a web network, this has been prototyped by Vanguard [15] and several universities including ours, and companies. We will create community pages such as this one for our Protégé work [16]. A web site for dissemination of information [17] has been created and explanations and examples of our research have been added. Many of the pages allow for editing and interactivity and the intention here is to create individual learning objects [18] which will be freely available. These will be created using open standard languages for ease of searching and reuse. These objects will enable people to create their own modelling web pages.

[1] Scaffidi, C., Shaw, M., Myers, B. (2005). Estimating the Numbers of End Users and End User Programmers, IEEE Symposium on Visual Languages and Human-Centric Computing, (VL/HCC'05): 207-214 Dallas, Texas.
[2] Select Committee on Science and Technology Third Report Chapter 2: Public Attitudes and Values - Attitudes to engineering 2.39 - http://www.publications.parliament.uk/pa/ld199900/ldselect/ldsctech/38/3804.htm
[3] Erwig M, Abraham R, Cooperstein I, Kollmansberger S, Automatic Generation and Maintenance of Correct Spreadsheets, 2005, ICSE 2005 27th International Conference on Software Engineering p 136- 145.
[4] Scanlan J, Rao A, Bru C, Hale P, Marsh R, DATUM Project: Cost Estimating Environment for Support of Aerospace Design Decision Making, 2006, Journal of Aircraft - 2006 vol. 43 no. 4
[5] Frankel D., Hayes, P., Kendall E., McGuinness, D. (2004) The Model Driven Semantic Web - 1st International Workshop on the Model-Driven Semantic Web (MDSW2004) Enabling Knowledge Representation and MDA® Technologies to Work Together.
[6] Berners-Lee T., 1999, Weaving the Web, Harper San Francisco, ISBN 0062515861.
[7] Olsson, E. (2004) What active users and designers contribute in the design process. Interacting with Computers 16, 377-401.
[8] Institute for End User Computing http://www.ieuc.org/home.html.
[9] Network of Excellence on End User Development EUD.Net http://giove.cnuce.cnr.it/eud-net.htm.
[10] End-Users Shaping Effective Software (EUSES) http://eusesconsortium.org/
[11] Gray J, Zhang J, Lin Y, Roychoudhury S, Wu H, Sudarsan R, Gokhale A, Neema S, Shi F, and Bapty T, Model-Driven Program Transformation of a Large Avionics Framework, 2004, Third International Conference on Generative Programming and Component Engineering GPCE.
[12] Marsh R, Hill T, J Scanlan, Dunkley M, Cleevely P, 2001, Probabilistic Pseudo-generative Cost Modelling Through Virtual Template Propagation CEAS Conference on Multidisciplinary Aircraft Design and Optimization June 2001 Maternushaus Koln, Germany.
[13] Murphy G C, Walker R J, Baniassad E L A, Robillard M P, Lai A, Kersten M A, Does aspect-oriented programming work?, 2001, Communications of the ACM, Volume 44 Issue 10 (October 2001) Pages: 75 - 77, ISSN:0001-0782
[14] Dmitriev S, Language Oriented Programming: The Next Programming Paradigm -http://www.onboard.jetbrains.com/is1/articles/04/10/lop/
[15] Global Knowledge Portal - http://wiki.vanguardsw.com/
[16] Protégé Community Wiki - User Driven Progamming - http://protege.cim3.net/cgi-bin/wiki.pl?UserDrivenProgramming
[17] SEEDS team Navigation Page http://www.cems.uwe.ac.uk/amrc/seeds/
[18] Polsani P R, Use and Abuse of Reusable Learning Objects,, 2003, Journal of Digital Information, Volume 3 Issue 4

One Day in history

Thousands of people across Britain are expected to contribute to a project aiming to create an online archive of a day in the life of the country.
The National Trust is encouraging people to record a diary of their day on a website, as part of what is being called "Britain's biggest blog".

The blogs will then be stored by the British Library and at other locations.

The trust says it will create a "fascinating social history archive" of everyday life for future generations.

Links

BBC Technology News - http://news.bbc.co.uk/1/hi/technology/6048392.stm

One Day in history - http://www.historymatters.org.uk/output/page96.asp

My Day

7.40 Got up - breakfast - Cous Cous with sauces, usual routine of walking to work except took the long route 2 miles instead of the short one 1 and a bit on cycle path in order to go to post office.

Started collecting money for St Peter's Hospice walk I took part in last Saturday.

Morning - Updated new Modelling page for our computer modelling research team. Commited to going to talk tomorrow morning on Business XML. Emailed my wonderful wife. Playing football so will have late lunch, eat fruit in late morning to keep sugar level normal for Football. Tuesday is lunchtime football day, organised by Applied Science Faculty members.
Afternoon - Packed Lunch - Sandwiches then work on Semantic Web Project Proposal.
Evening - Walked Home 6pm - Mexican tea and evening in with My wife.

User Driven Programming - Summary

My current research approach builds on previous work undertaken for a large aerospace company to allow designers and manufacturers to visualise and share cost information. During this project one task was to automatically produce tree representations of information requested by the user. Information held in a relational database was visualised and exported in structured languages.

The theory behind this is that of showing examples of a program in whatever way most puts across the information in an understandable way. This must illustrate the concept that the information represents. This allows a user to manipulate the information and get immediate feedback on what has changed. This is related to Programming by Example, which is explained below.

In the mid 1970s Smith introduced the technique of Programming by Example with a program called Pygmalion. This demonstrated the need to describe algorithms through concrete examples rather than abstractly. 'Example-based Programming: a pertinent visual approach for learning to program' University of Poitiers explains and expands on Smiths work with an example demonstrating how numbers fail to reveal the concept behind them. The example is a numerical representation of a triangle. This representation is 'fregean' because it does not show the concept of a triangle. Next to this is a diagram of the triangle that does show the concept.

The examples take the tree representations of a component and according to the properties of each feature of the component, a conversion tree in Vanguard Studio transforms the tree representation e.g this Spar into an SVG interactive diagrammatic representation.

This diagram explains the transformation process.



Figure 1 - Translation Process

These example images show some of the translation steps



Figure 1 - Protégé to Vanguard Conversion


Figure 2 - Web Tree View


Figure 3 - Web Diagram View

A Flash movie that explains how these are created using a simple example - User Driven Modelling Demonstration.

A taxonomy representation is translated into a computer model. Relationships can be conveyed to a software model that evaluates them. Information is translated from the taxonomy and is visualised in tree form in a decision support tool with the example of spar manufacture information. The visualisation of the information of a tree can be further translated into visualisation as an interactive diagram. The representation can be translated into differennt languages, to allow for language independence.

The process is also explained here - User Driven Programming, and here - Translation and Aspect-Oriented Programming, and Translation for De-abstraction.

This is my MSc research that I've based this SVG approach on - MSc Research Summary - The earliest research was into providing a user driven model development example that would enable the kind of user interface and visualisation required for interactive costing.

Examples both my own and those of others in this research field and explanations - http://www.cems.uwe.ac.uk/~phale/#SVGScalableVectorGraphics

How the examples are generated - Spar - Vanguard Studio software used to generate SVG from Protégé - Spar Example.

Programming by Example - Links

Alan Kay, Allen Cypher - Watch What I Do - Programming by Example.

Cypher A. (1993) Watch What I Do: Programming by Demonstration, The MIT Press

Example-based Programming: a pertinent visual approach for learning to program (2004) - University of Poitiers - Nicolas Guibert - Patrick Girard - Laurent Guittet - Proceedings of the working conference on Advanced visual interfaces - Pages: 358 - 361 - ISBN:1-58113-867-9.

Programming by Example - http://web.media.mit.edu/~lieber/PBE/index.html - Massachusetts Institute of Technology - MIT Lab.

Programming by Example Tutorial - http://giove.cnuce.cnr.it/EUD-NET/slides-workshop/PBE-Tutorial2.ppt - Henry Lieberman - MIT Lab - EUD-Net.

Pygmalion: A Computer Program to Model and Stimulate Creative Thought. Stuttgart, Basel - University of Calgary Summary - Smith, D. C. 1977.

Smith, D. C. (1977) A Computer Program to Model and Stimulate Creative Thought. Basel: Birkhauser. 187p.

Teaching and Learning Programming with a Programming by Example System - International Symposium on End User Development - Schloss Birlinghoven, Sankt Augustin (Bonn), Germany - October 6-7, 2003 - Nicolas Guibert, Patrick Girard.

AJAX World - Kurt Cagle XML.com

This report from Kurt Cagle is interesting reading, as he summarises presentations at this conference. There is also a link to the conference web page.

Live From AJAX World

Report 1 - http://www.oreillynet.com/xml/blog/2006/10/ajax_world_first_report.html - O'Reilly XML.com - Kurt Cagle - October 3, 2006.

AJAX on the Enterprise - Kurt Cagle

This is a transcript of the talk Kurt gave at the AJAXWorld Conference

http://www.oreillynet.com/xml/blog/2006/10/ajax_on_the_enterprise.html - Friday October 6.

Other AJAXWorld conference Information

This AJAXWorld conference was held on 2-4 October, The conference link is http://www.ajaxworldexpo.com/.

On the conference web site there is also a call for papers and date and location of the next conference

Call For Papers Open for AJAXWorld 2007
Rich Internet Applications – AJAX, Web 2.0, Flex, Flash, and Beyond...


SYS-CON Events is proud to announce the second AJAXWorld Conference & Expo for April 1-3, 2007 in New York City.

There is also a Web conference next year in Canada.

Web Directions North - http://north.webdirections.org/ - Vancouver Canada, February 6-10th 2007.

ACUITy application - General Electric

'Adaptive Work-Centered User Interface Technology (ACUITy) is now available on the SourceForge open source repository'

Release information - http://acuity.sourceforge.net/

I'm very interested in this semantic web application. I've seen this presented at the The Hewlett-Packard Jena conference Bristol UK. The paper is at http://jena.hpl.hp.com/juc2006/proceedings/crapo/paper.pdf and the presentation is at http://jena.hpl.hp.com/juc2006/proceedings/crapo/slides.ppt. The reasons that I'm interested in ACUITy are that it's a practical tool based on semantic web technology, such as Protégé and Jena, that can be used with minimal programming effort. This means it's relevant to my PhD research of using semantic web techniques to enable end-user programming. Also it looks particularly useful as a way of allowing engineers who create models using spreadsheets, to create shared models on a semantic web network.

OneWebDay

This OneWebDay celebration is something worth being part of because it's a small part of the history of the web. I hope this event happens every year, as the organisers plan.

I've just read on the BBC news web site that it's OneWebDay http://news.bbc.co.uk/1/hi/technology/5368190.stm, and bloggers are being encouraged to talk about this in their posts. This is important to me because most of the research I've undertaken for my PhD would not have been possible without the web, and particularly others research in the Semantic Web and Web 2.0. Particularly Tim Berners Lee's http://www.w3.org/People/Berners-Lee/ work has been a big influence.

Research into End User Programming using web technologies would have been difficult without the underlying technologies based on XML (eXtensible Markup Language), developed as part of the semantic web. Tim Berners Lee's work has been a big influence. Particularly important is research to take technologies from the Semantic Web, and apply this to web applications. Web 2.0 - Now people are also creating Rich Internet Applications using Ajax (Asynchronous JavaScript and XML) the whole area of world wide web research is so interesting and fast moving.

In the BBC article it says

'Susan Crawford, the founder of OneWebDay, said she wanted people to reflect on how the web had changed their lives.'

'The organisers are also encouraging people to post entries to their blogs on Friday which reflect on how the web has changed their lives.'

'This is the first OneWebDay, and the organisers plan for it to become an annual event.'


OneWebDay - http://www.onewebday.org/

OneWebDay - BBC article - http://news.bbc.co.uk/1/hi/technology/5368190.stm

PhD summary

I thought it would be useful to put a summary of my PhD on my blog, and this can help anyone visiting to know whether this research is of interest to them. As well as looking at my blog, anyone who is interested can look at the explanations, examples, and publications I have on my web site at http://www.cems.uwe.ac.uk/~phale/.

This thesis outlines the technique of user driven modelling. The idea behind this is that software users (in this case engineers) can create models that perform and visualise calculations (cost of manufacture and the reasons behind this cost). The advantage of this is that the engineers can share and adjust models without needing to call upon a software developer to create the model. The time saved can give engineers the chance to cost designs early. This could allow the design to be changed before most of the future costs are incurred.

The thesis explains how the above aims can be achieved, in order to enable decision support during product development, whilst minimising dependence on specialist software and detailed programming effort. The basis of this is an ontology that can be visualised and edited in tree form.

The early part of the PhD covers research of others from the 1960s to present day in End User Computing. This involves making it easier for those who aren't professional programmers to instruct computers. I'm particularly interested in visualisation of information, and allowing people to interact with this visualisation directly. This can allow the person to instruct the computer to perform calculations, and see the result without needing to write computer code.

I explore research into the semantic web which has been developed from the work of Tim Berners-Lee - http://www.w3.org/People/Berners-Lee/. I examine and demonstrate how this can be applied to decision support and modelling for engineers. I also examine how the semantic web technology could be applied more widely to modelling, and end user programming.

Examples demonstrate the application of meta-programming to the problem of program development. Meta programming is the writing of programs that write or manipulate other programs (or themselves) as their data. The idea behind my use of this technique is that instead of writing programs to do a task a domain expert needs the program for, the meta program developer creates an environment which all domain experts, in this and similar fields, can use to create their own solutions. The developer then only needs to maintain and improve this programming environment, and can concentrate on this task; the domain expert can concentrate on solving the problem at hand without having to ask the developer to create the code on his or her behalf. This can prevent problems of misunderstanding, delay, and expense that often result from communication of difficult concepts between people who are experts in different areas (domain expert and programming expert).

The examples are applied to the problem of assessing cost at an early stage in the design. To achieve this I examined the problems that prevented software products being effectively used to reduce cost at this early stage. These problems were lack of interoperability of software models created, and lack of structure for sharing and re-using models. A further problem was the difficulty found by engineers in attempting to understand and interpret models (mainly spreadsheets) created by their colleagues. The solution explored was to build into the software capabilities to save in neutral formats, to share and re-use models, and visualisation and interactivity, to ease model building and understanding.

It is very important to be able to establish an estimate of the cost of early designs, as failure to do so results in most of the cost being designed into the product at an early stage. By the later stages most of the costs are built in and it is too late to make major cost reductions. When engineering organisations design and manufacture products they categorise this process into stages. From the early concept stage to the final design stage and manufacture, software is used to aid and record the process. It is common for different software to be used at different stages. If the software applications do not use open standards languages to communicate between these stages and between the various teams involved, information gets lost and not re-used as the chain of information breaks. An open standard language is a language whose structure and syntax has been agreed by the World Wide Web consortium (W3C), http://www.w3.org/. The detail and accuracy of the information that can be provided to define the product varies along this chain. The best opportunities for cost reduction are early in the product life cycle, so it is important to gather together any information that is available on that component and any similar products. It is important that users who enter information about a design concept be guided by historical values where possible, and guidance information such as explanations, diagrams, and examples. The use of statistical modelling is necessary to ensure a cost can be calculated at this early stage when there is a high level of uncertainty.

The User-Driven Programming approach and its application to the problem above is explained using examples ranging from the visualisation and calculation of the area of a rectangle, to the modelling and costing of complex processes, and the visualisation of component design.

Squidoo Lens

I've been creating this Squidoo lens on User Driven Programming at http://www.squidoo.com/userdrivenprogramming/. This is an editable profile, and lets me create a central site to link web sites, blogs, RSS files and whatever else I might have published on the web. This is explained on the Squidoo blog at http://www.squidoo.com/blog/. It looks a very interesting tool.

It's of particular interest to me because it's both a good tool for me to link together my research, and an example of User Driven Prgramming itself.

Institute for End User Computing

I've joined the Institute for End User Computing, information about the organisation is here http://www.ieuc.org/. I'm working part time as an International Research Associate based in the UK. As part of this I'm writing about End User Programming, keeping track of other research that's relevant to this and continuing my own research mainly into using semantic web tools to allow user driven programming. If anyone has some interesting research in this area please let me know and I'll link to it, and let the Institute know as well. You could comment on this post or contact me at peter2.hale@uwe.ac.uk.

I think this goal is within site, with a new generation of easier to use and develop semantic web tools, and new environments for the creation of highly interactive web pages and applications it's becoming easier to create environments for end user programming.

Composing the Semantic Web

TopBraid Composer - http://www.topbraidcomposer.com/.

I've been looking for a semantic web tool that combines the functionality I've seen from Protégé, Jena, and a programming environment, and provides management tools to ease the effort of developing software. TopBraid Composer seems very promising, this is a toolset for developing ontologies combines the advantages of ease of use of development of Protégé with searching based on Jena and the Java Eclipse programming environment. This means that if I want to I can create software totally in the TopBraid Composer environment unlike my examples of http://www.cems.uwe.ac.uk/~phale/InteractiveSVGExamples.htm, where I converted source trees to result trees via a separate program http://wiki.vanguardsw.com/bin/browse.dsb?det/Engineering/Aerospace/Wing%20Spar%20Translated%20from%20Protege%20Taxonomy, to perform decisions and calculations. It's good to be able to link different tools like this, but also good to have the choice to work purely within one environment.

I particularly like this blog posting that explains how this tool can Lifting Excel into the Semantic Web on Holger Knublauch's (TopBraid Composer developer) blog http://composing-the-semantic-web.blogspot.com/ on how the application can import and use Excel spreadsheets. This is particularly important for end-user development as spreadsheets are often the first application that end user programmers use to facilitate their software development.

I'll also be looking at General Electric's ACUITy tool which was presented at the Jena conference http://jena.hpl.hp.com/juc2006/proceedings.html, to provide this kind of functionality. http://www.opencyc.org/ also looks interesting but I don't know much about it yet.

Translation and Aspect-Oriented Programming

The diagram shows a plan for weaving Aspect-Oriented Programming http://aosd.net/ into translation that are provided for end-user-computer communication. Aspect-Oriented Programming can be used where certain tasks or properties do not fall within a natural hierarchy. These are called Cross-Cutting Concerns http://en.wikipedia.org/wiki/Cross-cutting_concern, these Cross-Cutting Concerns could be tasks the program needs to perform such as providing printing or security. This same technique could also be used for attributes that the program is to model for example if the program is to model an aircraft wings, a user with sufficient computer literacy skills can model the representation of the wing as a hierarchical diagram. The user can specify relationships between these items that make it possible to make calculations and decisions. For this model some parameters such as efficiency, weight and cost might not fit well in this hierarchical representation. So these parameters could be weaved into the program as cross-cutting concerns in a similar way to the computing parameters.

Once all parameters are weaved into the program it can be translated from a format most suitable to visualisation and user interaction (e.g. OWL Web Ontology Language) to users into a computer language such as Java for implementation. The program would calculate results, and these could be translated back to the user. The results would be fed back in the language used for user interaction and visualisation. XML (eXtensible Markup Language) can also be used in the translation as either a programming language AspectXML, or a language for representing results. The results could be visualised using stylesheets and interactive software, and where useful translated further into other kinds of representations other than trees e.g. SVG (Scalable Vector Graphics) diagrams and graphs.


Figure 1

Highly interactive web pages that act like programs to provide a user interface can be used to provide an interactive user driven programming environment.

Highly interactive web pages that act like programs to provide a user interface can be used to provide an interactive user driven programming environment.

For a practical example figure 2 explains the concept for a simple example of the representation of the equation E=MC2. This relationship can be defined by the user. Here this is achieved using an ontology tool (Protégé), and this definition can be read directly by Decision support software (Vanguard Studio) that can visualise the information and colour code it. For a more complex example a higher level user interface would be required to enable a user to define the problem, and a translation step to the computer readable model. Units have been left out as the type of equation used and values in it are not important to the concept. The software can translate the source model into a program and calculate results. The result program is then translated again into a result model defined using open standard languages such as XML and Java for human friendly visualisations of viewable as web pages/diagrams.



Figure 2

Examples are available from my home page at http://www.cems.uwe.ac.uk/~phale/.

Translation for De-abstraction

The purpose of my research into this problem is to find a way of translating the conceptual model as defined by a visual and human language representation into a structured representation that can be made use of by computers in order to generate program code. This involves the use of model-driven programming as a technique to assist this.

Model-Driven Programming

Model-Driven Programming involves two transformation techniques Model Transformation and Program Transformation. Model Transformation can be used to translate a model with a representation of the problem that a user would be familiar with, into a model with a representation that can be more directly translated into program code. Model Transformation can be applied to problems involving design models e.g., UML (Unified Modeling Language) diagrams, architectural descriptions, and requirements specifications. A fuller explanation is available at Program-Transformation.org a http://www.program-transformation.org/Transform/ModelTransformation. Program transformation is the act of changing one program into another. The languages in which the program being transformed and the resulting program are written are called the source and target languages, respectively. A fuller explanation is available at Program-Transformation.org http://www.program-transformation.org/Transform/ProgramTransformation.

Model-Driven Programming can be an important technique for dealing with complexity. [Gray et al, 2004] explains how this technique can assist in the development of software for a large avionics system.

Translation Steps

As far as possible the tools and techniques used should be open standard for ease of use, re-use or transformation on other hardware or software systems. The user should not have to type any computer code. Instead diagrams, natural language, and formulae would be used to define the source model.

A model as defined by the user could be translated to a model that is more suitable for a computer to interpret. The computer can interpret this model, and follow any relationships defined in it, make any calculations or decisions, and so provide the results. Recursion can be used to enable the computer to follow a diagrammatic representation of the problem without having to care about the names of objects. This is particularly tree for tree representations. Trees are defined recursively because their structure is recursive so it is natural to traverse them recursively. This deal with hierarchies and relationships, but for requirements outside this scope Aspect Oriented Programming [Elrad et al., 2001] could be used to capture and translate these requirements. Aspect Oriented Programming can be used where software functions can't be neatly attached to particular objects or nodes in a hierarchy. These are known as cross-cutting concerns as they may affect several nodes. A diagrammatic representation of the cross-cutting concerns can then be translated into a computer language representation such as AspectJ for Java [Kiczales et al, 2001] and AspectXML for XML (eXtensible Markup Language) http://www.oreillynet.com/xml/blog/2005/09/part_3_assets_atom_feeds_and_a.html.

A further translation is likely to be necessary from the program to a result model that should be created to express the results to a user. This model would be a categorized full description of all the results from the program. This should be represented using open standard information languages such as XML or languages derived from this. This enables the widest possible re-use of the information on different hardware and software systems. The result model could be represented diagrammatically or as categorized and linked web pages. The full translation may be as below

Source Model (Human Friendly Representation) - Source Model (Computer Friendly Representation) - Computer Program - Result Model - (Human Friendly Representation)

If the user can define the source model, remain largely unaware of how the result model is produced, can understand the Result Model, and this meets the expectations of the user, the translation is successful.

The diagram explains the concept for a simple example of the representation of the equation E=MC2. This relationship can be defined by the user. Here this is achieved using an ontology tool (Protégé http://protege.stanford.edu/) , and this definition can be read directly by Decision support software (Vanguard Studio http://www.vanguardsw.com/) that can visualise the information and colour code it. For a more complex example a higher level user interface would be required to enable a user to define the problem, and a translation step to the computer readable model. Units have been left out as the type of equation used and values in it are not important to the concept. The software can translate the source model into a program and calculate results. The result program is then translated again into a result model defined using open standard languages such as XML and Java for human friendly visualisations of viewable as web pages/diagrams.

Diagram - http://www.cems.uwe.ac.uk/~phale/Images/emc2translate.gif

References

Elrad,T., Filman, R. E., Bader, (2001) A. Aspect-oriented programming: Introduction. Communications of the ACM, 44, 10, 28-32.

Gray, J. Zhang, J. Lin, Y. Roychoudhury, S. Wu, H. Sudarsan, R. Gokhale, A. Neema, S. Shi, F. Bapty, T. (2004). Model-Driven Program Transformation of a Large Avionics Framework - Third International Conference on Generative Programming and Component Engineering GPCE, 361-378 - http://www.cis.uab.edu/gray/Pubs/gpce-2004.pdf.

Kiczales, G., Hilsdale, E. Hugunin, J., Kersten, M., Palm J., Griswold, W. G., (2001) Getting Started with AspectJ. Communications of the ACM, 44, 10, 59-65.

Research Summary - Enabling End User Programming

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, and for amateurs, home users and open source communities. 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.

Translation

So far in my research I have edited the ontology representation of the program to be created in an ontology tool Protégé, and investigated Jena. For each node in the tree there is a value (end nodes), or a mathematical formula that relates that node to other nodes. The ontology created is saved in a database and then read by a Decision Support tool Vanguard Studio. This tool interates through the ontology, and for each tree, and each node in the tree calculates the results of all the formulae. The calculated tree is then displayed with the results and a full visual description of the calculation e.g. Spar Tree.

The results can also be exported into representations using various combinations of HTML, XML, Java, Javascript or Flash as required, for a web page view and could be output in virtually any language by adapting my existing outputter code. Links from my home page demonstrate this. A further transformation can be made to translate the tree based representation of a component e.g. a spar to a diagrammatic view of the design.

program-transformation.org - Program Transformation - - Program-Transformation.Org: The Program Transformation Wiki.

Ontology Editing

There is a strong need for uniting of the approaches of top down ontology definition by a small group of experts with that of the bottom up approach of allowing all users to define the ontology. Software applications are needed that allow users with little software knowledge to edit and update ontologies themselves. The extent to which an organisation allows this depends on its structure but if this is completely prevented or not enabled in the first place, there will be user dissatisfaction resulting from their lack of involvement. It is also likely that progress in defining and editing the ontology would be delayed.

Capturing Information

One possibility that I have begun investigating is the use of XForms based web forms to capture the information required for each node in a tree. The XForms could be made to look like a web page, spreadsheet, or whatever tool the user is most familiar with. This could be used as a way to capture the information from the users for an ontology.

Some useful links for this are

FormFaces - http://www.formfaces.com/main.html - XForm - XML Form editing tool Tool.
FormsPlayer - http://www.formsplayer.com/content/index.html - XForm - XML Form editing tool Tool.
Orbeon - http://www.orbeon.com/ - Orbeon XForms Presentation Server.


Final Research - Putting it all together

Further possibilities for automation of the User-Driven interface involve the use of additional components to ontology tools, that would allow for integration and higher level manipulation of the ontology, translation software, calculation software, and the visual interface. This would allow me to concentrate more on the creation of the user interface for end-users, and the software architecture required for this rather than on the translation software itself, and enable me to create a fully finished User-Driven Programming application environment.

Some useful links for this are

Genral Electric ACUITy application - presentation.
Genral Electric ACUITy application - paper.

Metamomix - m3t4 and Metamomix Wiki

End User Programming

The graph below shows that users, given the right tools to program with, would be by far the largest group of program developers. As well as users there are two intermediate groups, and a small group of professional programmers.



Source - Scaffidi et al. [2005] based on data from US bureau of Labour Statistics.

These statistics were also explained and referred to in Myers et al. [2006].

A presentation of this is available at http://www.cs.cmu.edu/~bam/papers/EUPchi2006overviewColor.pdf.

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. I call this User Driven Programming (UDP), I use the term User Driven Modelling (UDM) to explain the application of User Driven Programming to model development. My research and those of others in the field 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 in the USA http://eusesconsortium.org/ and Network of Excellence on End User Development in Europe http://giove.cnuce.cnr.it/eud-net.htm. Fabio Paternò has investigated this subject as part of the End User Development in Europe network - Paternò [2005] http://giove.cnuce.cnr.it/cameleon/pdf/last-model-based%20approaches-IwC.pdf..

The diagram below illustrates the problem to be solved, this is the need to translate between human and computer. It also demonstrates the complexity of the problem that needs solving. This is the complexity that is present in most software systems. Complexity varies according to the needs of the application. The complexity of calculation increases as we move from the domains of knowledge management through to decision support and simulation. The increase in complexity is of calculation in this direction from knowledge management to decision support to simulation, and of information in the other direction from simulation to decision support to knowledge management. Kurt Cagle explains this complexity problem well on his blog at http://www.understandingxml.com/.



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 that are 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.

The research I have undertaken in this is available on My Home Page. There are many examples, papers and explanations on my site. I will write a summary of the research in my next posts.

There is a conference in Brighton - UK this year that is relevant to this research -

IEEE Symposium on Visual Languages and Human-Centric Computing - http://www.cmis.brighton.ac.uk/vlhcc/ - 2006 - Brighton, UK.

Kevin Morrill's Blog outlines ideas for functionality users might want, if they were enabled to create a program to provide it -

References

Myers, B., Ko, A., Burnett M. (2006). Invited Research Overview: End-User Programming Extended Abstracts, CHI'2006: pp. 75-80, Montreal, Canada.

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

Scaffidi, C., Shaw, M., Myers, B. (2005). Estimating the Numbers of End Users and End User Programmers, IEEE Symposium on Visual Languages and Human-Centric Computing, (VL/HCC'05): 207-214 Dallas, Texas.

User Driven Collaboration

I've been researching collaborative solutions engineering and design problems for years now, and it seems this is the year when systems for this will make their breakthrough. They've showed promise for some time and are now becoming available for implementation e.g. at the Jena conference that I attended - Proceedings at http://jena.hpl.hp.com/juc2006/proceedings.html.

I'm particularly interested in An Ontology-Based Architecture for
Adaptive Work-Centered User Interface Technology as this looks very useful
for large Aerospace and engineering companies such as those we deal with - -
http://jena.hpl.hp.com/juc2006/proceedings/crapo/paper.pdf,
http://jena.hpl.hp.com/juc2006/proceedings/crapo/slides.ppt.
We have also been using a Decision Support tool and are part of a modelling
network, an example of a model we added to this network to enable users to program and output
their model on the web is at http://wiki.vanguardsw.com/bin/browse.dsb?det/Engineering/Aerospace/Wing%20Spar%20Translated%20from%20Protege%20Taxonomy.

The projects are aimed at making it possible for end users who create Excel
spreadsheets to create software that becomes part of a more integrated
system. There are other projects that aim to enable users to create
searchable and interactive web based content more easily.

Some of the projects using Protégé may also be relevant to this http://protege.cim3.net/cgi-bin/wiki.pl?ProjectsThatUseProtege.

These End User Groups in USA http://eusesconsortium.org/ and Europe http://giove.cnuce.cnr.it/eud-net.htm may be able to take on this problem. If anyone has any information about projects to allow users to collaborate and create content please let me know.

Visual Editor for SVG? (Scalable Vector Graphics)

It would be interesting to know whether any companies or researchers, are working on a visual development environment for creating SVG (Scalable Vector Graphics) movies, and interactive components. This would be very useful, Flash, Viewlet Builder, and many other tools are good for creating movies and interactive presentations. However there is a need for something that has this ease of use, and produces the same kind of output, using open standard SVG.

This would provide the capability to represent each picture in an alternative way for the blind. Without this functionality, web developers need to manually provide a separate representation for blind people. I doubt that every web developer does this. The SVG output could be the basis of providing a Flash movie, from which information could be extracted automatically. This extracted information would provide the alternative representation for blind people and non-Flash users. Also such a tool would be very good for allowing information to be extracted from the picture, e.g. values and labels from a graph, or attributes from a part diagram.

If the SVG items are grouped in an appropriate way this could make it possible to allow extraction of objects and properties represented in SVG that have a clear meaning. Adobe has acquired http://www.adobe.com/aboutadobe/invrelations/adobeandmacromedia.html, so perhaps they're doing something similar to Flash but with an SVG output? It would be good to see an automatic way of providing the sort of functionality illustrated at http://www.cems.uwe.ac.uk/~phale/InteractiveSVGExamples.htm. This is output automatically from a taxonomy represented in Protege, through a Decision support system DecisionPro http://www.vanguardsw.com/.

This sort of thinking ahead by software suppliers would make it much easier for ordinary users to provide good interactive content for the web. This is the basis of 'End User Development', a technique for making it easier for computer literate non-developers to create software. In this case the application of this technique would be enabling the construction of accessible interactive web pages.

User Driven Modelling - Background Information

Explanation of the Problem to be Addressed

Research Aim

This research arises out of work 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 manufacturing products. This thesis identifies ways that problems arising from the model development process can be addressed by a new way of providing for the creation of software. With 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). 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.

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 research, 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. The program translates this human readable representation into computer languages.

Research Approach

This research demonstrates how a taxonomy can be used to automatically produce software. This technique is most suitable at present to modelling, visualisation, and searching for information. The research explains the technique of User Driven Model Development that could be part of a wider approach of User Driven Programming. 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 and Protégé.

My 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.

An absolute requirement of this research is that no compromise is made in the openness of the source code of the application or of the information represented within the application. It is proposed that software and information represented by the software be separated but represented in the same open standard searchable way. This 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 using computer languages. To achieve this any layer of software 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 should be represented by the same languages and in the same way. The methods used for this representation and translation will be explained in the rest of this document.

Why a different approach is needed

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 every day 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 the developer would then become more that of a mentor and enabler rather than someone who has to translate all the ideas of the expert into code themselves.

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 from 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' http://www.w3.org/People/Berners-Lee/Weaving/Overview.html. The research examines ways of structuring information, and enabling processing and searching of the information to provide a modelling capability.
UDM could also 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 are 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 factors necessary to make the User Driven Model Development approach later outlined possible.

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. 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.

Building Developer Communities

I'm looking for communities and sites that have a mix of those with advanced software skills who want to encourage and enable others to learn to program, and of new starters who want to learn. I'm interested in those who are willing to try out new techniques to make it easier for newstarters (I retrained with vocational courses and Government schemes myself). Anyone interested can reply to this post, or email me at peter2.hale@uwe.ac.uk. I'll link my home page and blog to such sites.

I'm intending to share modelling knowledge by using semantic web techniques to enable a wide range of people to create web models to visualise common problems. Semantic web software will be used to categorise and manage these models. Events would take place to allow a community of developers and users to share their knowledge.

I'm putting examples, and explanations of every form of programming that I've done, and there are 2 others in our team who have also been doing this. I'm also meeting with other semantic web researchers about this idea. I'm particularly interested in SVG, XML, and JavaScript as good languages for web visualisation. I think my page http://www.cems.uwe.ac.uk/~phale/InteractiveSVGExamples.htm has my best examples as they are very interactive SVG examples for IE and Firefox, and I can't find such examples anywhere else, also I can automate the production of these examples from a database. I'm also linking my examples of all types to examples from other web sites. So I'm interested in anyone who has relevant examples.