User Driven Modelling: July 2007

Saturday, July 28, 2007

Dagstuhl Seminar End-User Software Engineering - Part 4 - Final Part

In 'Meta-User Interfaces for Ambient Spaces: Can Model-Driven-Engineering Help?' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1082 Joëlle Coutaz explains how Model Driven Engineering and Service Oriented Architecture can be combined -

"Our approach to UI plasticity brings together MDE (Model Driven Engineering) and SOA (Service Oriented Architecture) within a unified framework that covers both the development stage and the runtime phase of interactive systems."

Coutaz also explains that -

"An interactive system is a graph of models related by mappings and transformations."

This would fit in well with the structure of RDF (Resource Description Framework) a Semantic Web standard which is also a graph structure.

In 'Model-Driven Development for End-Users, too!?' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1085 Gregor Engels of University of Paderborn explains that UML (Unified Modeling Language) should be extended to allow development of user interfaces in order to assist end-users to program -

"The UML is strong in modelling the internal functionality of a software system, but weak in modelling user interface aspects of a system. Thus, with respect to the well-known MVC (Model-View-Controller) pattern, the UML supports the Model aspect, while neglecting the View and Controller aspect."

In 'Position Paper for Dagstuhl 2007 EUSE Workshop' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1094 Mary Beth Rosson of Pennsylvania State University explains their development of a drag and drop interface for web based visual programming.

In 'Rethinking the Software Life Cycle: About the Interlace of Different Design and Development Activities' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1084 Yvonne Dittrich of University of Copenhagen argues that more research is needed into the software lifecycle and methods and tools needed for end-user developers, especially when they are collaborating. These end-users often need to adjust old software for new purposes.

In 'Software environments for supporting End-User Development' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1081 Maria Francesca Costabile, Antonio Piccinno also explain that new methodologies and environments are required for supporting end-user collaborative development.

In 'What is an End-User Software Engineer?' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1080 Steven Clarke of Microsoft examines the characteristics of end-user developers in order to assist with meeting their needs.

My home page is http://www.cems.uwe.ac.uk/~phale/.

I have a page on End-User Programming at http://www.cems.uwe.ac.uk/amrc/seeds/EndUserProgramming.htm.

Friday, July 27, 2007

Dagstuhl Seminar End-User Software Engineering - Part 3

In 'Exploiting Domain-Specific Structures For End-User Programming Support Tools' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1086 Robin Abraham and Martin Erwig of Oregon State University integrate spreadsheet modelling into the UML modelling process.

In 'Interdisciplinary Design Research for End-User Software Engineering' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1078 Alan Blackwell explains the need for interdisciplinary research on the end-user programming problem to identify techniques within software engineering that can assist with this problem.

In 'Meta-Design: A Conceptual Framework for End-User Software Engineering' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1087 Gerhard Fischer of University of Colorado, Center for LifeLong Learning and Design (L3D) explains the concept of Meta-Design -

"Meta-design is an emerging conceptual framework aimed at defining and creating social and technical infrastructures in which new forms of collaborative design can take place. It extends the traditional notion of system design beyond the original development of a system. It is grounded in the basic assumption that future uses and problems cannot be completely anticipated at design time, when a system is developed."

Fischer also explains that it is the mismatches between their needs and the software support that enables new understandings.

Fischer argues the need for allowing end-users to design software -

"A great amount of new media is designed to see humans only as consumers. The importance of meta-design rests on the fundamental belief that humans (not all of them, not at all times, not in all contexts) want to be and act as designers in personally meaningful activities. Meta-design encourages users to be actively engaged in generating creative extensions to the artifacts given to them and has the potential to break down the strict counterproductive barriers between consumers and designers."

Fischer also argues that software development can never be completely delegated to software professionals because domain experts are the only people that fully understand the domain specific tasks that must be performed.

He puts forward a hypothesis that this emphasis on end-user development also changes the emphasis on testing -

"Software testing is conducted differently. Because domain expert developers themselves are the primary users, complete testing is not as important as in the case when the developers are not the users."

He also argues for an approach to enabling end-user programming possible that makes it interesting to end-users -

"Many times the problem is not that programming is difficult, but that it is boring (as we were told by an artist). Highly creative owners of problems struggle and learn tools that are useful to them, rather than believing in the alternative of "ease-of-use," which limits them to preprogrammed features."

My home page is http://www.cems.uwe.ac.uk/~phale/.

I have a page on End-User Programming at http://www.cems.uwe.ac.uk/amrc/seeds/EndUserProgramming.htm.

Thursday, July 26, 2007

Dagstuhl Seminar End-User Software Engineering - Part 2

End-User Software Engineering - Dagstuhl Seminar - Summary - http://www.dagstuhl.de/en/program/calendar/semhp/?semnr=2007081 - PDF Abstracts and links to papers - http://eusesconsortium.org/docs/dagstuhl_2007.pdf - Margaret M. Burnett, Gregor Engels, Brad A. Myers and Gregg Rothermel - From 18.01.07 to 23.02.07, the Dagstuhl Seminar 07081 End-User Software Engineering was held in the International Conference and Research Center (IBFI), Schloss Dagstuhl. During the seminar, several participants presented their current research, and ongoing work and open problems were discussed.

I have been reading this abstracts paper from the Dagstuhl Seminar End-User Software Engineering and it has lots of interesting points to make.

In 'End-User Design' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1099 Professor Alexander Repenning of University of Lugano explains the need for enhancements to UML (Unified Modeling Language) to aid end-user programming.

He makes the point that

"Visual programming languages using drag and drop mechanisms as programming approach make it virtually impossible to create syntactic errors."

So -

"With the syntactic challenge being – more or less – out of the way we can focus on the semantic level of end-user programming."

In 'End-User Development Techniques for Enterprise Resource Planning Software Systems' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1097 Michael Spahn, Stefan Scheidl, and Todor Stoitsev explain SAP research into End-User Programming, they explain -

"End-users of ERP systems are domain experts but not necessarily IT professionals, limiting their ability to adapt the software by themselves to their own needs and forcing them to indirectly influence the adaptation processes by communicating their needs to IT professionals. Empowering the end-users to adapt the software by themselves is an important step in reducing customization costs and enabling high-quality tailoring of software and working environments to the needs of modern information and knowledge workers."

They explain that users must be empowered to explore, process, and analyse information in a user friendly way, and create and adapt reports and queries. An abstraction layer should ease this by hiding technical details to allow for concentrating on business needs.

In 'End-User Software Engineering and Professional End-User Developers' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1095 Judith Segal of the Open University examines issues and problems in Professional end-user development, the author explains -

"These developers are distinguished from other end-user developers in two ways. The first is that, consistent with their being familiar with formal notations and logical scientific reasoning, they tend to have few problems with coding per se. The second is that, as a class, they have a history of developing their own software which long predates the advent of the PC."

In 'End-User Software Engineering Position Paper' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1092 by Henry Lieberman of MIT Media Laboratory he asks -

"Why is it so much harder to program a computer than simply to use a computer application? I can't think of any good reason why this is so; we just happen to have a tradition of arcane programming languages and mystically complex software development techniques. We can do much better."

He goes on to explain -

"HCI has amassed an enormous body of knowledge about what makes interfaces easy to use, and this has been applied widely to many computer applications for end users. Oddly, little of this has been applied to making interfaces for programming easier to use. Non-experts tend to believe that programmers practice a kind of voodoo, perceived to be naturally arcane and mysterious. Since they can handle it so well, programmers aren't perceived as needing ease of use. But we all pay the price for this misconception."

Lieberman explains the goal of this research -

"Finally, as much as is possible, we should make this process as automatic as we can, though the use of program transformation, dependency maintenance, automated reasoning, mixed-initiative interfaces, visualization, and machine learning. Otherwise, I think it will be too much overhead for a non-expert user themselves to keep track of the myriad facets that software development entails. If we succeed in this, people will become End-User Software Engineers without their even realizing it."

My home page is http://www.cems.uwe.ac.uk/~phale/.

I have a page on End-User Programming at http://www.cems.uwe.ac.uk/amrc/seeds/EndUserProgramming.htm.

Wednesday, July 25, 2007

Dagstuhl Seminar End-User Software Engineering - Part 1

I have been reading this abstracts paper from the Dagstuhl Seminar End-User Software Engineering and it has lots of interesting points to make.

In the introduction the report http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1098 states - "The number of end users creating software is far larger than the number of professional programmers. These end users are using various languages and programming systems to create software in forms such as spreadsheets, dynamic web applications, and scientific simulations. This software needs to be sufficiently dependable, but substantial evidence suggests that it is not."

This is a good point, and can be related to a point in 'Barriers to Successful End-User Programming' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1091 by Andrew Ko http://www.cs.cmu.edu/~ajko Carnegie Mellon University about end-user programmers

"Some of them are scientists, some are artists, others are educators and other types of professionals. One thing that all of these people have in common is that their goals are entirely unrelated to producing code."

Andrew Ko explains how this causes a problem -

"the fact that end-user programmers are motivated by their domain and not by the merits of producing high-quality, dependable code, means that most of the barriers that end users encounter in the process of writing a program are perceived as distractions. This is despite the fact that such barriers can represent fundamental problems in end-users' program's or their understanding of how to use a programming language effectively."

the problem is -

"how can tools help end-user programmers' improve their programs' dependability, while allowing them to remain focused on their goals, rather than their code?"

An important part of the solution is to visualise the whole program execution not just the output. Andrew Ko states -

"when a user was trying to diagnose their program's failure, they had to base their hypothesis of what caused the failure just on what they could see in the program's output, rather than on information about the program's execution. In many of these situations, users premature decisions led to errors."

A further problem is that of programs which were intended to be temporary and owned by a particular person becoming central to a company, this often happens with spreadsheets. Ko explains -

"We frequently hear anecdotes about how a one-off excel spreadsheet meant to be temporary became the centerpiece of some accounting logic. How often do such organizational dependencies occur, and how important do such program's become? What can tools do to help the future owners of these programs learn about the program's history and design?"

Mark D Gross explains Carnegie Mellon University work involving end-user programming by designers using diagrams and scratchpads in "Designers Need End User Software Engineering" http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1090.

In "End User Programming for Scientists: Modelling Complex Systems" http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1077 Andrew Begel of Microsoft Research explains -

"Model creation cannot be turned over to a programmer-for-hire without causing the model to become a black box. In order to ensure the validity of the model and stand behind its experimental results, the scientist must be intimately knowledgeable about its innards as well as its outward behaviors."

Text based Computer languages are often too obscure for end-user programmers, Bagel explains -

"Learning a text-based programming language is difficult for novices who want to be programmers. In the first few weeks of learning a language, syntax rules are often the most difficult to comprehend, with semantics interleaved. Non-programmers face these problems, in addition to lacking an engineering mindset to help form mental models of how they want to make the computer do what they want."

In 'End-user (further) development: A case for negotiated semiotic engineering' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1083 Clarisse Sieckenius de Souza of Departamento de Informática, PUC-Rio makes the Quote Liberman et al -

"We think that over the next few years, the goal of human-computer interaction (HCI) will evolve from just making system easy to use (even though that goal has not yet been completely achieved) to making systems that are easy to develop"

From

Lieberman, H.; Parternò, F.; Klann, M.; Wulf, V. (2006) End-user development: An emerging paradigm. In End-User Development (Lieberman, Paternò and Wulf, Eds.). Springer. p. 1.

My home page is http://www.cems.uwe.ac.uk/~phale/.

I have a page on End-User Programming at http://www.cems.uwe.ac.uk/amrc/seeds/EndUserProgramming.htm.

Monday, July 23, 2007

User Driven Modelling - Detailed Explanation - Part 5 - Conclusion

Comparison of the approach of developing decision support models using a spreadsheet, to the approach of User Driven Modelling, with open standards languages.

I compared the approach of developing decision support models using a spreadsheet, for design and costing, to the approach of User Driven Modelling, with open standards languages, and a web interface for this purpose. I conclude that the use of spreadsheets for this purpose is beset by problems. These relate to Maintenance, Extensibility, Ease of Use, and Sharing of Information.

But an alternative is required so modellers can continue their work without having to rely on software developers. The alternative approach involves development of a system, where a model builder, via visual editing of library taxonomies can undertake maintenance and extension of information. As yet a prototype only has been created for this, and a great deal more work is required to finalise the structure for the holding of this information, and agree standards for terminology. Also I need to provide more validation of user input.
However dealing with this proof of concept has indicated to us that it is far easier to maintain, search and share information using this approach than it is using spreadsheets. The ability to visualise, search and share the information using structured languages and web-pages, is a huge advantage, and allows us to create dynamic image views and decision support models over the web.

Home Page - http://www.cems.uwe.ac.uk/~phale/.
End User Programming - http://www.cems.uwe.ac.uk/amrc/seeds/EndUserProgramming.htm.
Semantic Web Modelling - http://www.cems.uwe.ac.uk/amrc/seeds/ModellingSemanticWeb.htm.

Friday, July 20, 2007

User Driven Modelling - Detailed Explanation - Part 4 - Translation

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

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

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

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

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

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

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

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

References

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

Tuesday, July 17, 2007

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

Why a different approach is needed

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

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

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

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

User Driven Model Development

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

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

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

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

Criteria necessary for User Driven Model Development

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

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

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

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

References

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

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

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

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

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

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

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

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

Friday, July 13, 2007

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

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

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

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

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

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

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

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

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

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

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

Thursday, July 05, 2007

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

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

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

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

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

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

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

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

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

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