British Computer Society (BCS) - Future visions blog

This British Computer Society (BCS) - Future visions blog began in January 2009. The blog is at http://www.bcs.org/server.php?show=ConBlog.20, and the creators welcome participation and they describe it here -

"We all have a keen interest in the future because, as the saying goes, we are going to spend the rest of our lives there.

As we well know, computers, computing and technology in general are having an ever increasing impact on our lives, the economy and society.

The BCS is delighted to have brought together four distinguished bloggers to share their thoughts and concerns on wide-ranging areas such as whether Big Brother really is watching us, is it for our own good or should we be worried, the digital divide, social networking, can we really trust our lives to the 'cloud', the impact on UK plc, and how to develop engineers to build the increasingly complex and interdependent systems of tomorrow.

We welcome your thoughts and comments on the posts in this blog."

Customer service - a defect in a technical society - Professor Roger James

This summary br Professor Roger James - http://www.rogerjames.net/ - University of Westminster, for a talk given the the BCS (Bristish Computer Society) Sociotechnical group https://owa.uwe.ac.uk/exchweb/bin/redir.asp?URL=http://www.bcs.org/server.php?show=nav.9926 summarises current problems and possible solutions for IT customer service. This highlights how better concentration on end-user requirements can save resources in the use of the technology.

I've copied the talk summary below -

"The genius of Google is you get a first rate technical experience with zero support [ie no customer service department]. Their whole business model is service free - relying instead on great technology, building and maintaining user competence and an ethos of self help. As a trivial but pertinent example there are approx 3500 books on Microsoft Office and 5 on Google apps - yet google apps offers substantially the useful elements of office. Should we consider this 'inbalance' a defect in Microsoft Office and should we anticipate a campaign on service quality akin to the six sigma product quality initiative over the last 20 years. Can one argue that technology is finally becoming sufficiently mature and ubiquitous to imagine this happening?"

Benefits from Enabling End User Programming

My research is to test an approach of using digital technology, to make software and modelling development easier for computer literate end users. This would then enable them to solve problems to help their, and their teams’ work to be more productive. The current problem is that the communication and translation steps required between users, and software developers, and help desk are too many, and too varied, this results in cost, uncertainty, delays, confusion, and confrontation. The solution is for software developers to develop more customisable software that can be customised by end-users.

An example is user’s development of spreadsheets, this indicates user’s willingness to use and develop software to meet their needs, but productivity in spreadsheet development can be poor, as they are difficult to track, and share. More advanced software tools are often not available to users, or take too long to learn. Semantic Web technologies can provide a solution to this by provision of free and customisable, shareable, and fully visualised applications for use in particular sectors. Development of such applications, and their use in industry would be proof of this.

More Customisable Software Systems

My experience of dealing with projects that create new software systems is that they are very ambitious, but not very modular or customisable. Under management pressure for meeting of timescales, they are often released too early with insufficient consultation with users. Then software developer's time is reallocated to a help desk, in order to deal with the problems caused by the release of software too early, too unchangeable and with too little user involvement.

A solution is to produce highly customisable software, so that the software team don't have to anticipate every problem the users will want to solve. Then many users with more advanced needs and computing abilities could customise software for their needs.

Modelling Methodology - User Driven Modelling

The User Driven Programming approach advocated in this research has the advantages that it is using a modelling approach for creating modelling solutions and involves creating systems to create systems. This makes it possible to solve the problem by breaking it down into stages and allowing software developers to concentrate on the most complex software problems and domain experts to be able to concentrate on their domain problem. The standardisation possible in this approach can allow software developers to create modelling systems for generic purposes that can be customised and developed by domain experts to model their domain. This methodology can be facilitated by :-

* Modelling Tools - Building an end-user interface and extending the translation capabilities of UML (Unified Modelling Language) and/or other modelling tools (Johnson, 2004).

* Spreadsheets - Improving the structuring and collaboration capabilities of spreadsheets, and enabling customisation of spreadsheet templates for particular domains and users.

*Ontology Tools - Extending the modelling capabilities and equation calculations in ontology tools and providing an end-user interface.
Semantic Web/Web 2.0 - Extending the capabilities of Semantic Web and Web 2.0 style web-based development tools to allow collaborative modelling.

* These possible solutions are not mutually exclusive and their combination could be the best way of providing usable collaborative modelling tools for computer literate end-users and domain experts. The link between these alternative ways of advancing current research is translation and User Driven Modelling/Programming.

This diagram shows the solutions, and how these could make User Driven Modelling/Programming possible :-

Methodology Diagram - Enabling User Driven Modelling/Programming

Johnson, P., 2004. Interactions, Collaborations and breakdowns. In: ACM International Conference Proceeding Series; Proceedings of the 3rd annual conference on Task models and diagrams Vol 86 Prague, Czech Republic.

Barriers to enabling end user programming

Please excuse the long gap since my last post, I was injured, and in hospital.

Now I'm out, I've been thinking about what the barriers are that hinder research into end user programming.

I think the essence of the problem is that organisations and individuals have many problems resulting from the lack of facilities to allow users to program. This causes many issues, which need to be urgently tackled in the short term. This creates an ironic dilemma, that the problems caused by lack of end user programming facilities cause there to be a need to tackle these problems via quick fixes because they are so urgent. This makes it difficult to secure funding for longer term end user programming research.

As an example - many people use Excel for financial modelling, and engineering, business, and science models. As these models become large, the short term solution is to use Excel Visual Basic to aid navigation through the model. However, though this helps with the immediate problem, in the longer term it can be difficult to reuse the model, as the Excel spreadsheet creator has to go through his or her code and remember what they have done, this problem is worse if a different user is trying to reuse the spreadsheet.

A longer term solution would be to provide a visual programming environment where the structure of the code is visualised, to make it easier to track the formulae, and so navigation is a central part of the program design, this also minimises the need for code.

The problem with this is that when organisations have urgent needs to produce models for a particular deadline, all their effort goes into this. Once a deadline is met or missed, there will be a new deadline for something else. So all the effort goes into meeting these deadlines, and there are little or no resources for providing a better solution that makes it easier in the long run to meet the deadlines.

Home Page - http://www.cems.uwe.ac.uk/~phale/
Google Home Page - http://sites.google.com/site/userdrivenmodellingprogramming/index

Automated Production of Engineering Models

This example demonstrates the research I have undertaken into automating the model creation process for engineering process models.

This example is of manufacturing a cube, where the cost of manufacture depends mainly on the size of the cube, its wall thickness, what material is used, and what process is used. This is a simple example, a real world example involving hand layup of a spar (wing component) proved to be too complicated for ease of demonstration explanation, especially over the web.

An ontology (held in Protege http://protege.stanford.edu/) is used to represent the common information needed for all cube models, (and other models) produced. The ontology is broken down into sub ontologies for parts, materials, processes, consumables, resources, and tooling. These are colour coded in the visualisation/interactive model to ease understanding.

Code written for this research is used to recursively read the Protege tree (via nested SQL calls), and reproduce the tree in the modelling system (Vanguard System http://www.vanguardsw.com/products/vanguard-system/). The modelling system enables calculations, and extra code written for this research also allows choices to be made by the user/modeller.

This simple example enables the user/modeller to make choices of the material, process, consumables, resources, and tooling to be used, for the manufacture of this cube. In this example choices were made for material - Aluminium, and process - Rivetting.

Cube Model

This model is then output to an online representation (this works in Internet Explorer only, a version for Mozilla Firefox is also in progress). The IE version requires the Adobe SVG player, currently downloadable, and free).

The online SVG (Scalable Vector Graphics) representation provides an interactive CAD type representation of the component, that can be manipulated, to change size and wall thickness. The wall thickness is indicated by the inner dotted cube. As the size or wall thickness of the cube is altered, immediate feedback is provided. Alterations can be made with the up/down buttons. Also if these values, or the Aluminium cost per metre cubed are changed, the calculated parameter and cost values change automatically, in response.

The SVG representation shown below can be found at http://www.cems.uwe.ac.uk/~phale/SVGCubeExample/CubePartDefinitionwithCosts.htm.

Cube Model - Translated to SVG

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

It is also possible to zoom in and out of the diagram, and move it around the screen.

As well as engineering models, I have experimented with economics models, and with translating either type of model to Java, and Java applets. Below is a screenshot of a simple economic model translated and visualised as an interactive Java applet.

Consumption Function translation from modelling system into Java

The models created as part of this research are available at - http://www.cems.uwe.ac.uk/~phale/EconomicModels/ModelsVisualised.htm.

Automation of knowledge representation and modelling

Knowledge management is a combination of the domains information is applied to and the technology used to represent this knowledge. The main domains I'm involved for representing this knowledge are engineering (process and design), and economics. The Semantic Web is key to this, but the Semantic web also involves many back end computing technologies such as databases/ontologies, and software tools/translation to represent this semantics/knowledge. To test this approach an application is necessary, to show benefits of the Semantic Web/knowledge management, and a way of testing it on the above domain. For my work, this problem used for testing is modelling, but in order to enable modelling using computing technologies, it is essential to make the modelling tools available to as great a range as possible of end-users. So this brings in the need for end-user programming, as to create models, it is necessary to program.

So my research area is as in the shaded ares of the diagram below -

Knowledge management and modelling are time consuming and difficult, this is only partly because of the technologies used, but my research focusses mainly on the technologies. When there are problems in keeping up with the needs of people, such as productivity problems in manufacturing, one of the solutions has been to mechanise this. So the mechanism I'm working on applies this idea to software. I'm working on enabling modelling, and programming for modelling, and what is necessary to ease this problem is provision of a machine. This machine undertakes translation and automated production of models from information. This is similar to the ideas behind virtual machines, interpreters, compilers, and UML tools, but there is more interaction with the users in the tools created for this research. So this enables customisation, at the same time as automation.

The models created are at - http://www.cems.uwe.ac.uk/~phale/EconomicModels/ModelsVisualised.htm.

More explanation of this research is at - http://sites.google.com/site/userdrivenmodellingprogramming/.

User Driven Modelling - Applications

This visual modelling is similar to collaborative spreadsheet modelling, but for these research models the visualisation and the code structure are exactly the same. This means users effectively can see an audit trail at all times in the modelling, and that the gap between those that program/model, and users is reduced. This makes both computing automated translation, and human collaboration/domain translation easier. This research is mainly aimed at users whose models/programs are too complex for spreadsheets. This means that themselves and other modellers/users lose track of information. These modellers/users often do not have the time and/or facilities for the programming tasks they need.

Automated translation and visualisation of models is essential as if they are manually copied by humans, there are almost certain to be errors in the copying of any large model to a different system. For such models an error anywhere in the model makes the result wrong. Visualising over collaborative networks, and of the whole structure also allows those responsible for checking and maintenance of each individual part of it to spot any mistakes, so this again acts as an effective audit trail.

Demonstration interactive models are shown at - http://www.cems.uwe.ac.uk/~phale/EconomicModels/ModelsVisualised.htm.

Research Methodology - Automated Model Production

Models are constructed and translated in a different way from object oriented programming. There is no clear distinction between classes and objects, as a class only becomes an instance gradually as translations are made from step 1 to 3, and as the models are visualised, interacted with, and represented to users. In the early research an ontology was translated and created from a C++ program, and also from a database. Now, models are created in the Vanguard System (http://www.vanguardsw.com/products/vanguard-system/) modelling tool, with information imported to this from a Protégé ontology, via the nested SQL queries. Vanguard System performs the calculations necessary for the economic model. After inferencing/calculation a result ontology is created for step 3. The step 3 result ontology/taxonomy is created by manually coding, then a system is created to reproduce and output this code automatically. This translation is then tested on many different models to ensure it is generic.

The diagram below examines many of the ways translation could be used for User Driven Modelling/Programming. An example of the repeatable process of this design is that the ‘System Translator Program’ created in Step 1 produces a new ‘System/Translator Program’ in Step 2 which creates a Visualisation. This technique is used to translate an ontology to a CAD style diagram using a second stage of translation. The second ‘System Translator Program’ could also have created a ‘Model/Program’, ‘Meta Program’ or translate to an ‘External Application’. So, this is not an exhaustive diagram, as many types of translation not shown on this diagram would be possible. Another option is that Step 1 could be repeated to translate between ontologies.

Translation Process for User Driven Modelling/Programming (UDM/P)

The ontology represents the relationships between nodes in a machine independent way, so this makes it possible to translate the information into Meta languages via recursive querying. For Step 2 translation, SQL (Structured Query Language) is then used to access the underlying database representation of the ontology. These SQL calls cycle recursively through all the relationships and write out result code for each node, and each relationship automatically. The translation code reads node names and node types (e.g. class, attribute) so it can make an appropriate SQL call for each node, and make a copy in another language or system, then look for children or attributes. This allows any tree to be represented in computer languages. Then recursive routines write the programming language to be output.

More information is available at http://sites.google.com/site/userdrivenmodellingprogramming/index.

Models produced so far are available at - http://www.cems.uwe.ac.uk/~phale/EconomicModels/ModelsVisualised.htm.

Economic Models 2

These economic models are constructed and translated in a different way from object oriented programming. There is no clear distinction between classes and objects, as a class only becomes an instance gradually as translations are made, and the models are visualised and represented to users.

At present the main focus is on extending the translation to interactive representations in Java and JavaScript. These will allow users to amend the parameter values of models and to see the result recalculated.

Once all or most of the translations are fully working, I'll concentrate on adding multiple models. Each model could then be translated automatically to many different visualisations/representations. I'll concentrate mainly on economic models, but might also eventually include other kinds of equation based models.

Economic Models - previous post - http://userdrivenmodelling.blogspot.com/2008/11/economic-models.html.

Economic Models Example -
http://www.cems.uwe.ac.uk/~phale/EconomicModels/ModelsVisualised.htm.

Java Applet Example - http://www.cems.uwe.ac.uk/~phale/EconomicModels/Bized/ConsumptionFunctionVanguardOutput/ConsumptionFunctionVanguardOutputInteractive/build/ConsumptionFunctionModelJavaAppletVanguardInteractive.html.

Economic Models

In order to prove the concept that User Driven Modelling is applicable to domains outside engineering, I'm developing economic models using the same kind of translation technique as I used for engineering models. Models are created in the Vanguard System (http://www.vanguardsw.com/) modelling tool, and can be imported to this from Protégé http://protege.stanford.edu/, via nested SQL queries. Vanguard System performs the calculations necessary for the economic model.

The next step is to visualise the Models in the web browser, and in various languages, to show the concept of multiple language implementations being created from one model. These multiple language implementations all share the same semantics and provide a tree based representation of this semantics.

These are demonstrated at http://www.cems.uwe.ac.uk/~phale/EconomicModels/ModelsVisualised.htm, different representations are provides, so that hopefully at least one representation is accessible to the various web browsers. So far there is an XML, HTML, and Java Applet representation. My intention is to extend both the representation of models and the number and type of models represented, until there is a large grid of models, and representations. Options for extending the representation are to JavaScript, SVG, RSS, RDF, and meta programs, and to increase, the interactivity/editability of the models.

This technique should allow automated creation of many models and language representations of them automatically, using one set of model code outputters/translators.

I'm getting the economic models from Biz/ed - http://www.bized.co.uk/educators/he/spreadsheet/section_1.htm. Eventually I might extend this to other types of models as well as engineering and economic models.

The implementation of the models is at http://www.cems.uwe.ac.uk/~phale/EconomicModels/ModelsVisualised.htm.

User Driven Programming/Modelling, and wider participation

A user-driven approach to visualisation, modelling, and programming can improve software and ease it's creation and maintenance. Translation then becomes posible from the user's representation to a software representation, and from design to implementation.

For User Driven Programming, 'user' can mean individual and/or organisation. The technique can be applied soonest to modelling/programming problems that require calculation. E.g. scientific, engineering, and business problems. The basis of the technique is enabling the information to be represented in a structured format e.g. XML (eXtensible Markup Language), RDF (Resourece Description Framework), RSS (this can stand for 3 different things - http://en.wikipedia.org/wiki/RSS_(file_format), and OWL (Web Ontology Language). Visualisation and interaction with the information can be enabled in a standardised way because the information is structured. This enables diagrammatic editing for modelling/programming. Careful structuring of the information and models/programs simplifies the modelling/programming process. A translation process from abstract/domain models to code can then be provided using recursive techniques.

As the structure and design and editing process for these models/programs can be standardised this enables a common meta-programming based methodology. Visualisation of this methodology to allow User Driven participation could enable wider participation than is currently possible for open source development, which is limited to more technical users. Visualisation at different levels of abstraction from domain to software could enable end-users, designers, and software developers to communicate in a semi-structured way in order to establish procedures for ensuring software is produced that end-users want to use.

Berners-Lee not happy with IE

This is an interesting article that can be found on the BCS (British Computer Society) website http://www.bcs.org/server.php?show=conWebDoc.21549.

"Internet Explorer is not up to speed with other browsers when it comes to offering support for scalable vector graphics (SVG), according to Tim Berners-Lee.

SVG is often found in online maps as it allows images to be resized or zoomed into without losing resolution.

Mr Berners-Lee, head of W3C, does not like to express preference for browsers and so did not name IE by name, reports the Associated Press.

'If you look around at browsers, you'll find that most of them support scalable vector graphics,' he told the agency.

'I'll let you figure out which one has been slow in supporting SVG.' Firefox, Safari and Google's new browser Chrome all support SVG, while Microsoft prefers a different format called Vector Markup Language - despite W3C giving SVG its support since 2001.

If IE users want to display SVG they need an Adobe plug-in, which is set to have its support ended on January 1st."

SWRL (Semantic Web Rule Language) and Protege

SWRL is a Semantic Web Rule Language Combining OWL and RuleML - http://www.w3.org/Submission/2004/SUBM-SWRL-20040521/.

So far in creating ontologies for modelling for my thesis, if-then-else structures were edited using simplified english language. Elenius et al. explain that Protege now supports SWRL. This makes it possible to use SWRL expressions within Protege. So if-then-else and other control structures could be specified using SWRL. Protege provides an expression builder for this purpose. This also opens up the possibility of translating between an english representation of such structures and an SWRL structure or vice versa, so would be useful future research.

Protege support for SWRL is through the SWRLTab, and has been available since 2004 - http://protege.cim3.net/cgi-bin/wiki.pl?SWRLTab.

This paper by Elenius et al. is available online - The OWL-S Editor - A Development Tool for Semantic Web Services - http://owlseditor.semwebcentral.org/documents/paper.pdf - Daniel Elenius, Grit Denker, David Martin, Fred Gilham, John Khouri, Shahin Sadaati, and Rukman Senanayake - SRI International, Menlo Park, California, USA.

This is the relevant paragraph - Refering to their own research - "One aspect of OWL-S services not covered in this paper is the editing of preconditions and effects of processes, and conditions associated with control constructs such as If-Then-Else. In OWL-S, these are normally described in the SWRL language. Currently, we simply provide a text box where users can enter these SWRL expressions. However, we plan to provide more user-friendly editing capabilities. Protege has recently" ... (2004)... "been enhanced with native support for SWRL, including a SWRL expression-builder, which will serve as the basis of this work."

One possible application of this would be using OWL-S, and UML type diagrams to produce interoperable process models diagrammatically.

More information on OWL is at http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/RDF/RDF.htm#OWL.

More information on SWRL is at http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/RDF/RDF.htm#SWRLRuleML

The Protege homepage is - http://protege.stanford.edu/.

Semantic Web Programming

Semantic Web Programming would allow searching the Semantics within programs rather than just outputs. This would be a step on from open source programming, this would allow open semantics programming. The code could then be visualised and interacted with using all the tools available for visualising semantic web languages. The whole tree/graph structure of a program could be visualised and searched easily.

Programming with XML is already enabled, and progress can now be made in using those languages such as RDF and OWL which are higher in the Semantic Web stack.

Programming with XML is possible using XForms, XQuery, Simkin, Metal, and many Rich Internet Application development environments.

Programming is becoming possible using OWL and OWL-S (OWL for Web Services). Visualisation of OWL structures enables editing by using UML Activity Diagrams, and OWL models programming structures such as if-then-else, and while loops.

Useful Links

Berners-Lee, T., Semantic Web - XML2000 - Architecture - http://www.w3.org/2000/Talks/1206-xml2k-tbl/slide10-0.html

Dmitriev, S., Jetbrains - Meta Programming System - http://www.onboard.jetbrains.com/is1/articles/04/10/lop/ - Language Oriented Programming: The Next Programming Paradigm - Sergey Dmitriev.

From BPEL4WS Process Model to Full OWL-S Ontology - http://www.eswc2006.org/poster-papers/FP13-Aslam.pdf - Muhammad Ahtisham Aslam, Sören Auer - University of Leipzig Germany, Jun Shen - University of Wollongong Australia - ABSTRACT - BPEL4WS is one of the most utilized business process development languages. It can be used to develop executable business processes as a combination of Web Services interactions in a specific sequence called process flow. But still BPEL4WS lacks sufficient representation of business process semantics required for business processes automation. On the other hand OWL-S (OWL for Web Services) is designed to present such kind of semantic information. There exists similarity in the conceptual model of OWL-S and BPEL4WS that can be used to overcome this lack of semantics in BEPL4WS by mapping the BPEL4WS process model to the OWL-S ontology. The mapped OWL-S service can be dynamically discovered, composed and invoked on the basis of matching semantics. Such a process of mapping syntax based Web Services composition in the form of BPEL process model to Semantic Web Services composition in the form of OWL-S composite service can also enable automation of BPEL processes as OWL-S services by applying AI planning techniques. In this paper we present a mapping strategy and a mapping tool that can be used to map BPEL processes to the OWL-S suite of ontologies.

Introduction to OWL - http://www.w3schools.com/rdf/rdf_owl.asp - OWL is a language for processing web information. What You Should Already Know Before you study OWL you should have a basic understanding of XML, XML Namespaces and RDF.

MetaL - http://www.meta-language.net/ - MetaL: An XML based Meta-Programming language.

OWL - http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/RDF/RDF.htmOWL

OWL-S API - http://www.mindswap.org/2004/owl-s/api/ - Mindswap - Maryland Information and Network Dynamics Lab Semantic Web Agents Project - OWL-S API provides a Java API for programmatic access to read, execute and write OWL-S (formerly known as DAML-S) service descriptions. The API supports to read different versions of OWL-S (OWL-S 1.0, OWL-S 0.9, DAML-S 0.7) descriptions. The API provides an ExecutionEngine that can invoke AtomicProcesses that has WSDL or UPnP groundings, and CompositeProcecesses that uses control constructs Sequence, Unordered, and Split. Executing processes that relies on conditionals such as If-Then-else and RepeatUntil is not supported in the default implementation. But this implementation can be extended to handle these constructs if the application that uses the OWL-S descriptions has a custom syntax and evaluation procedure for the conditions.

OWL-S Editor - http://owlseditor.semwebcentral.org/download.shtml - Download.

OWL-S Editor - http://iswc2004.semanticweb.org/demos/02/paper.pdf - Grit Denker and Daniel Elenius and David Martin - SRI International, California, USA, Linkoping University, Linkoping, Sweden - INTRODUCTION - An increasing number of organizations are endorsing Web Services (WS) technology to extend corporate resources to customers and partners and to leverage resources of others. AlthoughWeb Services, based on XML technology, allow interoperability, they do not support efficient and flexible search, allocation, composition, runtime monitoring, or invocation of those Web Services. Semantic Web Services (SWSs) use semantically rich annotations to facilitate these tasks. Richer semantics can provide fuller, more flexible automation of service provision, and use and support the construction of more powerful tools and methodologies.

OWL-S Editor to Semantically Annotate Web-Services - http://staff.um.edu.mt/cabe2/supervising/undergraduate/owlseditFYP/OwlSEdit.html - University of Malta - Department of Computer Science and A.I. - James Scicluna - The current version of the Owl-S Editor can be downloaded from here. We welcome any feedback related to how the tool was used and how effective it was to solve your particular needs. Let us know so that we can improve the tool.

OWL-S: Semantic Markup for Web Services - http://www.daml.org/services/owl-s/1.1/overview/ - Abstract - The Semantic Web should enable greater access not only to content but also to services on the Web. Users and software agents should be able to discover, invoke, compose, and monitor Web resources offering particular services and having particular properties, and should be able to do so with a high degree of automation if desired. Powerful tools should be enabled by service descriptions, across the Web service lifecycle. OWL-S (formerly DAML-S) is an ontology of services that makes these functionalities possible. In this document we describe the overall structure of the ontology and its three main parts: the service profile for advertising and discovering services; the process model, which gives a detailed description of a service's operation; and the grounding, which provides details on how to interoperate with a service, via messages.

OWL Web Ontology Language Guide - http://www.w3.org/TR/owl-guide/ - W3C Recommendation 10 February 2004 - The World Wide Web as it is currently constituted resembles a poorly mapped geography. Our insight into the documents and capabilities available are based ..word searches, abetted by clever use of document connectivity and usage patterns. The sheer mass of this data is unmanageable without powerful tool support. In order to map this terrain more precisely, computational agents require machine-readable descriptions of the content and capabilities of Web accessible resources. These descriptions must be in addition to the human-readable versions of that information.

The OWL-S Editor - A Development Tool for Semantic Web Services - http://owlseditor.semwebcentral.org/documents/paper.pdf - Daniel Elenius, Grit Denker, David Martin, Fred Gilham, John Khouri, Shahin Sadaati, and Rukman Senanayake - SRI International, Menlo Park, California, USA - Abstract. The power of Web Service (WS) technology lies in the fact that it establishes a common, vendor-neutral platform for integrating distributed computing applications, in intranets as well as the Internet at large. Semantic Web Services (SWSs) promise to provide solutions to the challenges associated with automated discovery, dynamic composition, enactment, and other tasks associated with managing and using service-based systems. One of the barriers to a wider adoption of SWS technology is the lack of tools for creating SWS specifications. OWL-S is one of the major SWS description languages. This paper presents an OWL-S Editor, whose objective is to allow easy, intuitive OWL-S service development and to provide a variety of special-purpose capabilities to facilitate SWS design. The editor is implemented as a plugin to the Protege OWL ontology editor, and is being developed as open-source software.

The OWL-S Editor - A Domain-Specific Extension to Protégé - Elenius, D., 2005. - 8th Intl. Protégé Conference - July 18-21, 2005 - Madrid, Spain.

Programming with XML - http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/XML/XML.htmProgrammingwithXML

Rich Internet Applications - http://www.cems.uwe.ac.uk/amrc/seeds/Ajax/ajax.htmRichInternetApplications

Simkin - http://www.simkin.co.uk/- A high-level lightweight embeddable scripting language which works with Java or C++ and XML.

VISUAL MODELING OF OWL-S SERVICES - http://members.deri.at/~jamess/pdfs/scicluna-iadis2004.pdf - Msida MSD 06, Malta (Europe) - Mr. James Scicluna, Mr. Charlie Abela, Dr. Matthew Montebello, Department of Computer Science and Artificial Intelligence, University of Malta - ABSTRACT - The Semantic Web is slowly gathering interest and becoming a reality. More people are becoming aware of this and are trying to embed Semantic Web technologies into their applications. This involves the use of tools that can handle rapid ontology building and validation in an easy and transparent manner. In the area of Semantic Web Web Services (SWWS) an OWL-S specification defines a set of ontologies through which a semantic description of the service can be created. At times this is not an easy task and could result in an incorrect specification of the description or even lead the fainthearted user to resort to some other type of description language. This paper describes the OWL-S editor tool that provides two methodologies in which such a web services description can be developed without exposing the developer to the underlying OWL-S syntax. These methodologies are based on a mapping from WSDL to OWL-S and on modeling a composite service using standard UML Activity Diagrams.

XForms - http://www.cems.uwe.ac.uk/amrc/seeds/Ajax/ajax.htmXForms

XQuery - http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/XML/XML.htmXQuery

Semantic Web Interest Group - SWIG-UK event, Bristol UK

==== SWIG-UK - A Semantic Web Community Event

Hewlett-Packard Bristol

We would like to invite users and developers interested in the
semantic web to attend a community event to be held at HP Labs
Bristol, UK on Tuesday 11 November 2008. This will be an opportunity
for you to meet other users and developers and to share experiences
with semantic web applications.

The day will a mixture of discussion, demos, short presentations,
with a few longer presentations if offered. The objective is to
allow people to share experiences of using the semantic web. The
agenda will be driven by the attendees; it is not limited to Jena
applications nor limited to the UK.

Please register early so we know there is critical mass for the event.

Registration: swig-uk-2008@sparql.net

Further Information - http://groups.yahoo.com/group/semanticweb-southwest/ - Directions: http://www.hpl.hp.com/bristol/directions.html.

Meta-Programming as a Model Creation Technique

Model-Driven Programming and Meta-Programming together with Semantic Web and End-User Programming techniques are vital ingredients of the User Driven Programming/Modelling approach used in this thesis. Dmitriev (2006) explains the problem to be solved in order to improve model production as “limitations of programming which force the programmer to think like the computer rather than having the computer think more like the programmer.” Meta-programming (Dmitriev, 2006) is a useful way of allowing for language independent software development, and can aid in providing a high level front-end to programming languages. “Meta-programming is the writing of programs that write or manipulate other programs (or themselves) as their data” (Wikipedia, 2008).

The idea behind use of meta-programming in this thesis 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. Dmitriev (2006) advocates reducing dependency on languages and environments by enabling programmers to develop their own specific languages for solving each domain problem:

"If we are going to make creating languages easy, we need to separate the representation and storage of the program from the program itself. We should store programs directly as a structured graph, since this allows us to make any extensions we like to the language. Sometimes, we wouldn't even need to consider text storage at all. A good example of this today is an Excel spreadsheet. Ninety-nine percent of people don't need to deal with the stored format at all, and there are always import and export features when the issue comes up. The only real reason we use text today is because we don't have any better editors than text editors. But we can change this... Text editors... don't know how to work with the underlying graph structure of programs. But with the right tools, the editor could work directly with the graph structure, and give us freedom to use any visual representation we like in the editor. We could render the program as text, tables, diagrams, trees, or anything else. We could even use different representations for different purposes, e.g. a graphical representation for viewing, and a textual representation for editing. We could use domain specific representations for different parts of the code, e.g. graphical math symbols for math formulas, graphic charts for charts, rows and columns for spreadsheets, etc. We could use the most appropriate representation for the problem domain, which might be text, but is not limited to text. The best representation depends on how we think about the problem domain. This flexibility of representation would also enable us to make our editors more powerful than ever, since different representations could have specialized ways to edit them."

This provides a way to create programs that create programs so enabling the 3 step translation process used in this thesis, and this enables translations between people, between systems, and between languages. This could enable those who are not currently programmers to create models at their domain level using domain specific systems created for them by programmers. The mechanisms for this are recursive translation of the tree/graph code representation to multiple models and languages, where necessary aided by user/modeller choices.

References

Dmitriev, S., 2007. Language Oriented Programming: The Next Programming Paradigm - http://www.onboard.jetbrains.com/is1/articles/04/10/lop/.

Fischer, G., 2007. 'Meta-Design: A Conceptual Framework for End-User Software Engineering' http://drops.dagstuhl.de/opus/frontdoor.php?source_opus=1087 - Dagstuhl Seminar Proceedings.

Wikipedia (2008) Metaprogramming - http://en.wikipedia.org/wiki/Metaprogramming.

More information is available at - http://www.cems.uwe.ac.uk/amrc/seeds/softwareengineering.htm#MetaProgramming.

Open Standard Representation of Rules and Equations

SWRL

Miller and Baramidze (2005) explain and SWRL (Semantic Web Rule Language). Zhao and Liu (2008) examine the need for sharing product information between partners as a product model, and how agreement through ontologies, Semantic Web, and standards can assist this. Zhao and Liu examine mapping of STEP representations to ontology languages OWL - http://www.cems.uwe.ac.uk/amrc/seeds/PeterHale/RDF/RDF.htm#OWL and SWRL and how this benefits interoperability. Zhao and Liu are encoding STEP rules and executable statements into OWL and SWRL. Zhao and Liu also show a diagram (similar to this one of Berners-Lee) of the position of OWL and SWRL in a stack of standards from XML in the Syntax layer up to OWL/SWRL in the Logic/Rule layer of 'Semantics'.

SWRL (Semantic Web Rule Language) combining OWL and RuleML and its use in modelling will also be investigated. This could be used for formally specifying the construction of equations and rules in a model and the relationships and constraints between items represented in an equation. Miller and Baramidze (2005) explain the SWRL language. An editing facility to model these equations and constraints, so that errors could be prevented, would improve the usability of future visual modelling systems created. Support for SWRL in Protégé and other ontology based systems will assist with the construction of a modelling system with sophisticated editing of rules (Miller and Baramidze, 2005). Miller and Baramidze (2005) examine efforts to develop mathematical semantic representations above the syntactical representations of MathML. SWRL also has standardised arithmetic and comparison operators (Zhao and Liu, 2008). These languages should enable standardisation of the representation of mathematical expressions that relate nodes, and their values and expressions; this would seem to be a difficult problem as it needs a user interface that enables complex mathematical structures to be conveyed by language and/or diagrammatic visualisation.

References

Miller, J A., Baramidze, G., Simulation and the Semantic Web - 2005. - Proceedings of the 2005 Winter Simulation Conference.

Zhao, W. and Liu, J.K. 2008. OWL/SWRL representation methodology for EXPRESS-driven product information model Part I. Implementation methodology, Computers in Industry - Article in Press, Corrected Proof - Abstract - This paper presents an ontology-based approach to enable semantic interoperability and reasoning over the product information model. The web ontology language (OWL) and the semantic web rule language (SWRL) in the Semantic Web are employed to construct the product information model. The traditional modeling language called EXPRESS is discussed. The representation methodology for EXPRESS-driven product information model is then proposed. The key of the representation methodology is mapping from EXPRESS to OWL/SWRL. Some illustrated examples are presented. - Keywords - Product information model; OWL; SWRL; EXPRESS; Ontology representation. Zhao and Liu (2008) are encoding STEP rules and executable statements into OWL and SWRL.

RuleML

The research of the Rule Markup Initiative is explained here. Rules for the Web have become a mainstream topic since inference rules became important in E-Commerce and the Semantic Web, and since transformation rules were put into practice for document generation from a central XML repository. Rules have continued to play an important role in artificial intelligence, knowledge-based systems, and for intelligent agents. This is now combined with standardisation in XML/RDF enabling use of declarative rules for web services. The Rule Markup Initiative has taken steps towards defining a shared Rule Markup Language (RuleML), enabling both forward (bottom-up) and backward (top-down) rules.

Reference

RuleML - The Rule Markup Initiative http://www.ruleml.org/.

Representation of Equations

Gruber (1993) examines how equations and quantities can be represented in an ontology. Kamareddine et al. (2004) examine how mathematics can be represented in order to make it easier for people to enter well-formed mathematical expressions.

Shim et al. (2002) examine translation from a users' model to equations and explain "converting a decision-makers' specification of a decision problem into an algebraic form and then into a form understandable by an algorithm is a key step in the use of a model". For a practical example the figure below explains the concept for a simple example of the representation of the equation E=MC². 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 viewable as web pages/diagrams.

Translation Process - Equations

References

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

Kamareddine, F., Maarek, M., Wells, J. B, 2005, Toward an Object-Oriented Structure for Mathematical Text - http://www.macs.hw.ac.uk/~jbw/papers/Kamareddine+Maarek+Wells:Toward-an-Object-Oriented-Structure-for-Mathematical-Text:MKM-2005.pdf - Mathematical Knowledge Management, 4th Int'l Conf., Proceedings, LNCS. Springer-Verlag.

Quint, V., Vatton, I., 2004. Techniques for Authoring Complex XML Documents - http://wam.inrialpes.fr/publications/2004/DocEng2004VQIV.html - DocEng 2004 - ACM Symposium on Document Engineering Milwaukee October 28-30 - This paper reviews the main innovations of XML and considers their impact on the editing techniques for structured documents.

Quint, V., Vatton, I., 2005. Towards Active Web Clients - http://wam.inrialpes.fr/publications/2005/DocEng05-Quint.html - DocEng 2005 - ACM Symposium on Document Engineering - 2-4 November 2005 - Bristol, United Kingdom. - Recent developments of document technologies have strongly impacted the evolution of Web clients over the last fifteen years, but all Web clients have not taken the same advantage of this advance. In particular, mainstream tools have put the emphasis on accessing existing documents to the detriment of a more cooperative usage of the Web. However, in the early days, Web users were able to go beyond browsing and to get more actively involved.

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

MathML

MathML is a specification for describing mathematics as a basis for machine to machine communication. It provides a way of including mathematical expressions in Web pages. This is explained at World Wide Web Consortium Math Home (2008). There is support for creation and editing of MathML documents in Amaya (Amaya, 2008), (Quint and Vatton, 2004 and 2005).

MathML and semantics built on this could assist in the process of translating equations/formulae into code by providing an open representation of functions as XML (eXtensible Markup Language). Functions entered by the model developer can then be translated to this open representation and translated to programming languages and/or read by programming languages.

Miller and Baramidze (2005) examine efforts to develop mathematical semantic representations above the syntactical representations of MathML.

References

Amaya - http://www.w3.org/Amaya/ - Welcome to Amaya - W3C's Editor/Browser - Amaya is a Web editor, i.e. a tool used to create and update documents directly on the Web. Browsing features are seamlessly integrated with the editing and remote access features in a uniform environment. This follows the original vision of the Web as a space for collaboration and not just a one-way publishing medium.

Miller, J A., Baramidze, G., Simulation and the Semantic Web - 2005. - Proceedings of the 2005 Winter Simulation Conference.

World Wide Web Consortium (W3C) Math Home, 2008. What is MathML? http://www.w3.org/Math/Overview.html.

Links

Coq proof assistant - http://coq.inria.fr/ - Coq is a formal proof management system: a proof done with Coq is mechanically checked by the machine.

End User Programming for Scientists: Modeling Complex Systems - http://drops.dagstuhl.de/opus/volltexte/2007/1077/ - Andrew Begel - Microsoft Research - In: End-User Software Engineering - Dagstuhl Seminar - Summary - http://www.dagstuhl.de/en/program/calendar/semhp/?semnr=2007081 - 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.

EquMath.Net - http://equmath.net/ - EquMath is resource for math lessons from Algebra to Differential Equations!.

Equplus - http://equplus.net/ - Science and Math Equations.

Mathematica - http://www.wolfram.com/ - Wolfram Research.

Mathematical Functions - Interactive Graph - http://www.richtann.com/2dExamples/graph.html - Richard Tann UWE - An Example using Actionscript to model functions and dynamically redraw according to user interaction.

MathLang: experience-driven development of a new mathematical language - http://citeseer.ist.psu.edu/kamareddine04mathlang.html - F. Kamareddine, et al., 2004 - Abstract: In this paper we report on the design of a new mathematical language and our method of designing it, driven by the encoding of mathematical texts. MathLang is intended to provide support for checking basic well-formedness of mathematical text without requiring the heavy and dicult-to-use machinery of full type theory or other forms of full formalization. At the same time, it is intended to allow the addition of fuller formalization to a document as time and e ort permits.

MathWeb - http://www.mathweb.org/ - MathWeb.org supplies an infrastructure for web-supported mathematics.

Mizar Project - http://mizar.org/project/ - The Mizar project started around 1973 as an attempt to reconstruct mathematical vernacular in a computer-oriented environment.

OMDoc.org - http://www.omdoc.org/ - OMDoc.org: The OMDoc Portal - OMDoc is a markup format and data model for Open Mathematical Documents. It serves as semantics-oriented representation format and ontology language for mathematical knowledge.

OpenMath - http://www.openmath.org/ - OpenMath is a new, extensible standard for representing the semantics of mathematical objects.

Richard Tann UWE - http://www.richtann.com/2dExamples/graph.html - Mathematical Functions - An Example using Actionscript to model functions and dynamically redraw according to user interaction.

Toward an Object-Oriented Structure for Mathematical Text - http://www.macs.hw.ac.uk/~jbw/papers/Kamareddine+Maarek+Wells:Toward-an-Object-Oriented-Structure-for-Mathematical-Text:MKM-2005.pdf - Kamareddine, F., Maarek, M., Wells, J. B, 2005, Mathematical Knowledge Management, 4th Int'l Conf., Proceedings, LNCS. Springer-Verlag.

SRML

SRML - Simulation Reference Markup Language - http://www.w3.org/TR/SRML/ - W3C Note 18 December 2002.

SRML case study: simple self-describing process modeling and simulation - http://ieeexplore.ieee.org/xpls/abs_all.jsp?arnumber=1371486 - Reichenthal, S.W. Boeing, Anaheim, CA, USA; 2004, Simulation Conference, 2004. Proceedings of the 2004 Winter - Volume: 2, pp 1461- 1466 - ISBN: 0-7803-8786-4.

End User Programming, Modelling and the Semantic Web

This diagram shows the research direction this thesis moved in over time.

• End-user programming for modelling. Research began with examining programming needs of users (mainly engineers at Airbus and later Rolls-Royce aerospace companies).
• Modelling – Next, models were created to cater for the engineers needs for prediction and decision support; so the concentration was mainly on modelling.
• Semantic Web for modelling. Once the models became more complex and numerous, the collaboration necessary required a more systematic infrastructure, so Semantic Web and ontology research assisted with this.
• Semantic Web for end-user programming. Once an infrastructure was prototyped it was possible to research how this could enable construction of programs based on the Semantic Web/ontology infrastructure.
• Programs created using the semantic web infrastructure and visual diagrammatic programming were tested for modelling capability.

Research Direction Spiral

By the end of this research it was perceived that this particular combination as indicated by the mid point of the yellow section was currently under researched by the wider community.

More information is available at - http://www.cems.uwe.ac.uk/~phale/#ResearchAim.