'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.
Monday, September 25, 2006
Friday, September 22, 2006
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
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
Tuesday, September 19, 2006
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.
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.
Monday, September 04, 2006
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.
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.
Tuesday, August 29, 2006
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.
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.
Friday, August 25, 2006
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.
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.
Tuesday, July 25, 2006
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/.
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/.
Friday, July 07, 2006
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.
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.
Friday, June 23, 2006
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
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
Thursday, June 15, 2006
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.
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.
Thursday, May 25, 2006
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.
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.
Monday, May 01, 2006
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.
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.
Tuesday, April 18, 2006
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.
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.
Friday, March 31, 2006
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.
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.
Friday, March 24, 2006
Thoughts on Complexity - Ontologies
here is another take on complexity (my last post, referring also to Kurt Cagles' http://www.understandingxml.com/), and the problems that arise from complexity. Representing information is another problem where complexity can preclude any single approach to the problem. In order to find our way around large quantities of information it needs to be structured. But the information already exists and is still being created, so this makes it a moving target. I'm sure such matters will be covered at the www2006 conference at Edinburgh 23-26 May http://www2006.org/.
The structuring of ontologies from the top down can be useful, but can only be achieved where the ontology developers have some control over the information. Much of web development and other creation of information is bottom up, in that there is no controlling authority. This is good for inclusiveness and speed of development, and something that encourages community, and encourages individuals to create their own content, which is a good thing. In his interview with the British Computer Society Tim Berners-Lee http://dig.csail.mit.edu/breadcrumbs/blog/4 in answer to a question on ontologies, talks of a top level ontology that can be created to hold certain terms and the need to find, out who is using these terms so that other web pages and databases can be categorised. This would be achieved using URIs and RDF. In answer to what Tim hopes to achieve, he talks of this bottom up development that is going on, using blogs, and wikis etc and a possible approach of 'web science' - 'the science and engineering of web based things that have a bottom up Web-like structure'.
I think this approach is highly relevant to my PhD research of user-driven programming. With UWE (University of the West of England), I'm putting forward a proposal for us and others to be involved in such an approach. In keeping with the open standard and open source approach I advocate above, the draft is available at http://www.cems.uwe.ac.uk/amrc/seeds/semanticwebmodelling.htm. This proposal is to allow creation and use of models by a community and to provide ways of sorting, searching and navigating these models.
Tim-Berners-Lee's interview - http://www.bcs.org/server.php?show=ConWebDoc.3337.
This talk by Nigel Shadbolt explains research about coping with diverse sources of information - http://www.bcs.org/server.php?show=ConWebDoc.3043.
This article by Bill Thompson for the BBC technology site examines new developments in Web 2.0 technologies - http://news.bbc.co.uk/1/hi/technology/4842498.stm.
The structuring of ontologies from the top down can be useful, but can only be achieved where the ontology developers have some control over the information. Much of web development and other creation of information is bottom up, in that there is no controlling authority. This is good for inclusiveness and speed of development, and something that encourages community, and encourages individuals to create their own content, which is a good thing. In his interview with the British Computer Society Tim Berners-Lee http://dig.csail.mit.edu/breadcrumbs/blog/4 in answer to a question on ontologies, talks of a top level ontology that can be created to hold certain terms and the need to find, out who is using these terms so that other web pages and databases can be categorised. This would be achieved using URIs and RDF. In answer to what Tim hopes to achieve, he talks of this bottom up development that is going on, using blogs, and wikis etc and a possible approach of 'web science' - 'the science and engineering of web based things that have a bottom up Web-like structure'.
I think this approach is highly relevant to my PhD research of user-driven programming. With UWE (University of the West of England), I'm putting forward a proposal for us and others to be involved in such an approach. In keeping with the open standard and open source approach I advocate above, the draft is available at http://www.cems.uwe.ac.uk/amrc/seeds/semanticwebmodelling.htm. This proposal is to allow creation and use of models by a community and to provide ways of sorting, searching and navigating these models.
Tim-Berners-Lee's interview - http://www.bcs.org/server.php?show=ConWebDoc.3337.
This talk by Nigel Shadbolt explains research about coping with diverse sources of information - http://www.bcs.org/server.php?show=ConWebDoc.3043.
This article by Bill Thompson for the BBC technology site examines new developments in Web 2.0 technologies - http://news.bbc.co.uk/1/hi/technology/4842498.stm.
Monday, March 13, 2006
Thoughts on Complexity - Kurt Cagle
The web site of Kurt Cagle http://www.understandingxml.com/ is an excellent source of information on specific technologies such as XML, XSLT, XUL, SVG, Java, and on the general direction of software and web research. The article 'Thoughts on complexity', which is also available at http://www.oreillynet.com/lpt/wlg/9280 explains the paradoxes involved in trying to make software easier to create and use. This article discusses complexity and abstraction as a complexity management tool. I recommend this is a site to go into the favourites of anyone involved in software development, and will be adding this to my links.
Wednesday, March 01, 2006
Automated Generation of Modelling Programs using Jena and Protégé
Abstract
This paper explains a 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 but the main practical work in creation of this system is in its' early stages. The basis of this approach is modelling of the software to be produced in Ontology systems such as Jena and Protégé.
Introduction
The Systems Engineering Estimation and Decision Support (SEEDS) team is part of the Aerospace Manufacturing Research Centre (AMRC) at the University of the West of England (UWE). SEEDS expertise is in applying techniques in managing, categorising and visualising information to provide decision support for design and manufacturing.
The SEEDS team have completed large projects and are experienced in creation of software for costing and decision support modelling. The SEEDS team recently completed the DATUM (Design Analysis Tool for Unit cost Modelling) project with Rolls-Royce aerospace. For this the team created sophisticated decision support models and web output.
The research outlined in this paper 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. This research examines ways of structuring information, and enabling processing and searching of the information to provide a modelling capability, and enable the automation of model production.
Collaboration
To achieve the aims outlined above it is necessary to allow model developers (who would be users of our software) to collaborate to share and develop models. The method of enabling this is to provide templates to enable non-programmers to develop software models for the purposes that interest them. [Olsson] explains the advantages of increasing user involvement in software development. Collaboration and knowledge sharing would be important in this process with models being sharable over the web. This form of collaboration would be based on the 'open source' method of co-operation where source code and explanations are added to a web site and comments and improvements would be encouraged. Some examples of this form of co-operation are the Wikipedia collaborative online encyclopaedia http://en.wikipedia.org/wiki/Main_Page, the Mozilla Firefox browser development http://www.mozilla.org/ and the Semantic Web Environmental directory (SWED) http://www.swed.org.uk/swed/about/. The intention is to create an online community that can provide and use free software for modelling and education. The advantages of open source collaboration are that as well as allowing researchers to co-operate and work together where they share an interest; it will also allow the untapped potential to be developed of those who do not have an official research position. This could include students, people employed outside the academic environment, retired people and amateurs' who have useful expertise. Astronomy for example has harnessed skills of this very diverse range of people to make new discoveries. The advantage of this wide involvement could be in getting feedback on usefulness, or ease of use of software, as well as their actual involvement in model development.
[Aziz et al.] Examine how open standards software can assist in an organisations' collaborative product development. The methods used and success of others that had used an approach of web based collaboration have been examined. This approach is outlined in [Ciancarini et al.]; [Huang and Mak]; [Kim et al.]; [Li]; [Morris et al.]; [Nidamarthi et al.]; [Reed et al.]; [Zhang et al.]. The above research reinforced our view that this is a sensible approach.
Methods
A web based collaborative approach is demonstrated on our SEEDS team web site at http://www.cems.uwe.ac.uk/amrc/seeds/. Examples of semantic web costing, searching, and decision support techniques will be freely available and could be used within universities and in outside industry and the community. Such modelling would be useful for, but not limited to, decision support for design and manufacture of products, simulation of manufacturing processes or business processes, economic forecasting, scientific modelling, medicine, business decision making, construction, and cost benefit analysis. It could also be used for modelling of systems for educational use. These models would illustrate and explain processes. Such modelling would be useful to universities as an illustration of concepts to students, and as a chance to participate in the development of modelling systems.
Software Approach
[Huhns] and [Paternò] 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.
Ontology systems such as Protégé http://protege.stanford.edu/, Jena http://jena.sourceforge.net/, and Kaon http://kaon.semanticweb.org/ either individually or in combination will be used to create our ontology. So far Protégé and Jena have been investigated for this. The use of RDF/XML (Resource Description Framework using Extensible Markup Language syntax) allows XQuery and SPARQL (SPARQL Protocol And RDF Query Language) http://jena.sourceforge.net/ARQ/ to be used for searching. The ability of Jena and Protege to save in relational database format also makes it possible to use SQL (Structured Query Language). Using these standards it is possible to represent information in Jena, Protégé, or other ontology systems. All this flexibility is useful when different organisations are not all using the same systems. An important reason for creating 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]. Research of others in this field have been investigated [Corcho]; [Corcho and Gómez-Pérez] and [Noy]. Issues involved in visualisation of lightweight ontologies are examined by [Fluit et al.].
This ontology could then be read into a decision support system which outputs results in web formats, this would also allow information that is relevant to different faculties or organisations to be shared. To enable creation of web pages by people who are not experts in this task, open source content management tool such as Rainbow Portal http://www.rainbowportal.net/ or the Zope Community Content Management Framework (CMF) http://www.zope.org/, which is currently used at UWE could be considered. Ajax techniques for creation of highly interactive web pages may assist in this http://ajaxpatterns.org/wiki/index.php?title=Whats_Ajax%3f.
Translation
This approach is to enable a type of very high level Meta programming. Meta-programming and structured language is explained by Dmitriev http://www.onboard.jetbrains.com/is1/articles/04/10/lop/ and [Mens et al]. This is intended to mitigate the problems of cost and time over-run, and failure to achieve objectives that are the common malaise of software development. The creation of a web based visual representation of the information will allow people to examine and agree on information structures. It is envisaged that a translation system to create software from diagrams that represent the problem is developed. The Figure illustrates our approach to provision of a system to enable users to create and/or use their own models.
This paper explains a 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 but the main practical work in creation of this system is in its' early stages. The basis of this approach is modelling of the software to be produced in Ontology systems such as Jena and Protégé.
Introduction
The Systems Engineering Estimation and Decision Support (SEEDS) team is part of the Aerospace Manufacturing Research Centre (AMRC) at the University of the West of England (UWE). SEEDS expertise is in applying techniques in managing, categorising and visualising information to provide decision support for design and manufacturing.
The SEEDS team have completed large projects and are experienced in creation of software for costing and decision support modelling. The SEEDS team recently completed the DATUM (Design Analysis Tool for Unit cost Modelling) project with Rolls-Royce aerospace. For this the team created sophisticated decision support models and web output.
The research outlined in this paper 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. This research examines ways of structuring information, and enabling processing and searching of the information to provide a modelling capability, and enable the automation of model production.
Collaboration
To achieve the aims outlined above it is necessary to allow model developers (who would be users of our software) to collaborate to share and develop models. The method of enabling this is to provide templates to enable non-programmers to develop software models for the purposes that interest them. [Olsson] explains the advantages of increasing user involvement in software development. Collaboration and knowledge sharing would be important in this process with models being sharable over the web. This form of collaboration would be based on the 'open source' method of co-operation where source code and explanations are added to a web site and comments and improvements would be encouraged. Some examples of this form of co-operation are the Wikipedia collaborative online encyclopaedia http://en.wikipedia.org/wiki/Main_Page, the Mozilla Firefox browser development http://www.mozilla.org/ and the Semantic Web Environmental directory (SWED) http://www.swed.org.uk/swed/about/. The intention is to create an online community that can provide and use free software for modelling and education. The advantages of open source collaboration are that as well as allowing researchers to co-operate and work together where they share an interest; it will also allow the untapped potential to be developed of those who do not have an official research position. This could include students, people employed outside the academic environment, retired people and amateurs' who have useful expertise. Astronomy for example has harnessed skills of this very diverse range of people to make new discoveries. The advantage of this wide involvement could be in getting feedback on usefulness, or ease of use of software, as well as their actual involvement in model development.
[Aziz et al.] Examine how open standards software can assist in an organisations' collaborative product development. The methods used and success of others that had used an approach of web based collaboration have been examined. This approach is outlined in [Ciancarini et al.]; [Huang and Mak]; [Kim et al.]; [Li]; [Morris et al.]; [Nidamarthi et al.]; [Reed et al.]; [Zhang et al.]. The above research reinforced our view that this is a sensible approach.
Methods
A web based collaborative approach is demonstrated on our SEEDS team web site at http://www.cems.uwe.ac.uk/amrc/seeds/. Examples of semantic web costing, searching, and decision support techniques will be freely available and could be used within universities and in outside industry and the community. Such modelling would be useful for, but not limited to, decision support for design and manufacture of products, simulation of manufacturing processes or business processes, economic forecasting, scientific modelling, medicine, business decision making, construction, and cost benefit analysis. It could also be used for modelling of systems for educational use. These models would illustrate and explain processes. Such modelling would be useful to universities as an illustration of concepts to students, and as a chance to participate in the development of modelling systems.
Software Approach
[Huhns] and [Paternò] 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.
Ontology systems such as Protégé http://protege.stanford.edu/, Jena http://jena.sourceforge.net/, and Kaon http://kaon.semanticweb.org/ either individually or in combination will be used to create our ontology. So far Protégé and Jena have been investigated for this. The use of RDF/XML (Resource Description Framework using Extensible Markup Language syntax) allows XQuery and SPARQL (SPARQL Protocol And RDF Query Language) http://jena.sourceforge.net/ARQ/ to be used for searching. The ability of Jena and Protege to save in relational database format also makes it possible to use SQL (Structured Query Language). Using these standards it is possible to represent information in Jena, Protégé, or other ontology systems. All this flexibility is useful when different organisations are not all using the same systems. An important reason for creating 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]. Research of others in this field have been investigated [Corcho]; [Corcho and Gómez-Pérez] and [Noy]. Issues involved in visualisation of lightweight ontologies are examined by [Fluit et al.].
This ontology could then be read into a decision support system which outputs results in web formats, this would also allow information that is relevant to different faculties or organisations to be shared. To enable creation of web pages by people who are not experts in this task, open source content management tool such as Rainbow Portal http://www.rainbowportal.net/ or the Zope Community Content Management Framework (CMF) http://www.zope.org/, which is currently used at UWE could be considered. Ajax techniques for creation of highly interactive web pages may assist in this http://ajaxpatterns.org/wiki/index.php?title=Whats_Ajax%3f.
Translation
This approach is to enable a type of very high level Meta programming. Meta-programming and structured language is explained by Dmitriev http://www.onboard.jetbrains.com/is1/articles/04/10/lop/ and [Mens et al]. This is intended to mitigate the problems of cost and time over-run, and failure to achieve objectives that are the common malaise of software development. The creation of a web based visual representation of the information will allow people to examine and agree on information structures. It is envisaged that a translation system to create software from diagrams that represent the problem is developed. The Figure illustrates our approach to provision of a system to enable users to create and/or use their own models.
Translation Process
To achieve this requires -
1 Search trigger(s) resulting from user actions.
2 Knowledge of the relationships between nodes in the tree.
3 Ability to read equations held in a standardised mathematical form.
4 Rules of syntax for the language of the code to be output.
The SEEDS teams' approach involves creation of an elaborator or translator that converts the diagrammatic representation of the problem into software, in various computer languages or a meta-programming syntax. The software created falls into two categories. The first category is structuring, sorting, and searching of information Jena http://jena.sourceforge.net/, Protégé http://protege.stanford.edu/, Exist XQuery http://exist.sourceforge.net/, Orbeon Xforms http://www.orbeon.com/. This kind of software can be both the ontology editor and the output format. The other category of software would be used for modelling and would be an output, this includes Cost Estimator [Koonce et al.] [Wujek et al.], metaL http://www.meta-language.net/ and Simkin http://www.simkin.co.uk/Links.shtml. The elaborator needs to follow a structured taxonomy to establish how related concepts represented visually can be represented in equivalent code. The visualisation can be either as a colour coded tree or an interactive SVG (Scalable Vector Graphics) http://www.cems.uwe.ac.uk/~phale/InteractiveSVGExamples.htm diagram of a component to be modelled.
The research undertaken aims to adapt or create software systems to provide the visual editor for the source tree, and allow model builders to create a model by editing this. By doing so the model builders would create a generic model for a particular modelling subject. DecisionPro http://www.vanguardsw.com/decisionpro/ can be used to convert the taxonomy into a decision support and modelling system. Vanguard is making their server available for collaborative model development. The model users could then use this decision support and modelling system to create their models. These models would be a more specific subset of the generic model, and could be applied for their own analysis. Our team would also provide a translation mechanism to convert information or models into other languages (primarily web based), and to visualise this information. Researchers could also create individual learning objects for education.
Conclusions
The technique of User Driven Programming can be achieved through the use of highly structured languages and visualisation of these structures to allow editing. Examples of software created this way are available at http://www.cems.uwe.ac.uk/~phale/. This project would give people more access to software for modelling, education, and allow them to develop their own software.
References
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.
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.
Ciancarini, P. & Rossi, D. & Vitali, F. (2001) Designing a document-centric coordination application over the Internet. Interacting with Computers, 13 677-693.
Corcho, O., 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.
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.
Fluit C., Marta S., Harmelen F. V., Staab S., Studer R. (2003) Handbook on Ontologies in Information Systems. Springer-Verlag.
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.
Huhns, M. (2001) Interaction-Oriented Software Development. International Journal of Software Engineering and Knowledge Engineering, 11 259-279.
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.
Li, W. D. (2005) A Web-based service for distributed process planning optimization. Computers in Industry, 56, 272-288.
Mens, K., Michiels, I., Wuyts, R. (2002) Supporting Software Development through Declaratively Codified Programming Patterns. Expert Systems with Applications 23, 405-413.
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.
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.
Noy N.F. (2004) Semantic Integration: A Survey Of Ontology-Based Approaches. SIGMOD Record, Special Issue on Semantic Integration, 33 (4).
Olsson, E. (2004) What active users and designers contribute in the design process. Interacting with Computers 16, 377-401.
Paternò, F. (2005) Model-based tools for pervasive usability. Interacting with Computers 17 (3), 291-315.
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.
Zhang, S., Weimen, S., Hamada, G. (2004) A review of Internet-based product information sharing and visualization. Computers in Industry, 54, 1-15.
Wednesday, February 08, 2006
User Driven Programming
Automated Generation of Modelling Programs
http://www.cems.uwe.ac.uk/~phale/
http://www.cems.uwe.ac.uk/amrc/seeds/
Introduction
http://www.cems.uwe.ac.uk/~phale/
http://www.cems.uwe.ac.uk/amrc/seeds/
Introduction
Software can be created using visual design techniques. This would speed up software design and development and allow users to build software. This article 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.
User Driven Programming
Software development is time consuming and error prone because of the need to learn computer languages. Instead the intelligence of users should be harnessed, to create software, improvements would feed back into future versions. Easing software development allows users to devote full effort to the problem to be solved. There should be no clear divide or hurdles for a computer literate user advancing into visual programming. User Driven Programming involves creating software that enables people to program using a visual representation. A tree representation is translated into computer languages. This technique is here applied to aerospace engineering, but it should be applicable to any subject.
The approach researched is illustrated in Figure 1.
Figure 1 - Source to Result Tree Translation
To achieve this requires -
1 Search trigger(s) resulting from user actions.
2 Knowledge of the relationships between nodes in the tree.
3 Ability to read equations held in a standardised mathematical form.
4 Rules of syntax for the language of the code to be output.
Translation
The 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.
Visualisation
Figure 2 shows how the program visualises information for the spar and its’ part definition and material. The model also includes manufacturing processes and cost rates and calculates a full cost breakdown.
Figure 2 – Tree based Visualisation
Figure 3 shows the spar translated into XML (eXtensible Markup Language) visualised using a stylesheet.
Figure 3 - XML Representation - See http://manudea.duemetri.net/manudea/xtree/default.asp
Figure 4 shows the spar translated into an SVG (Scalable Vector Graphics) diagram.
Figure 4 - SVG Representation
Figure 5 shows the spar translated to XML and visualised using Flash multimedia.
Figure 5 - XML visualised using Flash - See http://www.friendsofed.com/book.html?isbn=1590591585
Figure 6 shows the spar translated to Java and visualised using an applet.
Figure 6 - Java visualised by applet
The tree can also be translated into other languages; an alternative would be to translate into meta-languages.
Thursday, February 02, 2006
New SEEDS pages
The University of the West of England (UWE) web developers have created new pages for our UWE centre Aerospace Manufacturing Research Centre (AMRC). This means it's possible for anyone to navigate from the main UWE site to our pages. There are also new Systems Engineering Estimation and Decision Support (SEEDS) pages. The new AMRC page is at http://www.uwe.ac.uk/cems/research/centres/amrc/index.html. The new SEEDS pages are at http://www.uwe.ac.uk/cems/research/centres/amrc/seeds.html and http://www.uwe.ac.uk/cems/research/centres/amrc/seedsresearch.html.
Friday, January 27, 2006
XML Examples Using Schemas and DTDs
I've created new pages at to practice and illustrate XML, Schemas, DTDs and this displays events using a stylesheet. http://www.cems.uwe.ac.uk/amrc/seeds/EventsLists/XMLExamplesSchemaandDTD.htm
These XML examples demonstrate the use of a schema and a DTD for validating the XML. In them I have included a reference to the Schema, and a reference to the DTD (commented out) and the inclusion of the DTD within the XML document to show all 3 ways of validating the XML.
These are based on the Work of Chris Wallace and his Faculty Information Team at UWE (Andy Cowley, Nicholas Read, Amit Patel)
These XML examples demonstrate the use of a schema and a DTD for validating the XML. In them I have included a reference to the Schema, and a reference to the DTD (commented out) and the inclusion of the DTD within the XML document to show all 3 ways of validating the XML.
These are based on the Work of Chris Wallace and his Faculty Information Team at UWE (Andy Cowley, Nicholas Read, Amit Patel)
Subscribe to:
Posts (Atom)