Next:
Discussion and remarks from
Up:
Statements of the panelists
Previous:
Victor Marek
Terrance Swift
opened his statement with the following questions:
To what extent is ASP programming?
Is ASP a specification or an assembler language?
In order to answer these issues, Swift pointed out first some well-known model driven architectures and languages:
Ontology-driven architectures and agents
OWL
Ontology-driven agents
UML-driven architectures
Java IDEs, Delphi.net
Business engines like Bold, Epic, J2EE
OCL expressions
Workflow-type models (e.g. WfMC)
Open Business Engine
Swift then raised and answered some more questions:
What particular strengths does ASP bring to these problems?
In his opinion, these are
Non-monotonic reasoning (and preferences)
Fixpoint operator
Impressively fast engines (usually)
How should ASP be used in these BIG systems?
As a specification language?
As an assembly language? e.g. a reasoning co-processor?
What are the biggest weaknesses of current ASP systems?
Nearly non-existent user interface (need to think beyond emacs!)
APIs inadequate for widespread use
Swift then pointed out that using APIs in ASP (e.g., the C-API of Smodels) is a ``labor of love'' for the following reasons:
It is difficult to translate atoms to internal representation.
It does not translate weight constraints.
All constants must be known before commit.
There is no incremental commit.
All rules must be known before commit.
There are no ``background theories."
In comparing ASP with CLP, Swift pointed out the following observations.
Good operational understanding of how constraint store can fit with Prolog, C++, etc.
CLPQR is used in Sicstus, XSB, Yap, etc but not in ASP yet.
Constraint handling rules allow programmers to model new constraint theories.
Finally, Swift pointed out some possibilities for improvements:
Incremental commit of rules and programs
For compilation, and for ``abductive" programs.
Would allow incremental addition of ASP rules on forward execution
Would allow retraction of rules on backtracking via trail hooks, backtrackable updates
Would allow ``pruning'' of search space, like CLP
``Background Theories" e.g. inheritance
Allow guards in the bodies of rules
if the guards fire, a callback to an outside system is made, to incrementally ground call.
Semantically meaningful, programmer is only doing lazily what she would otherwise do eagerly.
Next:
Discussion and remarks from
Up:
Statements of the panelists
Previous:
Victor Marek
Stefan Woltran 2005-08-22