Logic languages are well suited for declaratively solving computational problems that require knowledge representation and reasoning. Object-oriented programming languages benefit from mature software ecosystems featuring rich libraries and developer tools. Several integration solutions exist that allow a software system to be decomposed into a combination of modules implemented in both a logic and an object-oriented language. Unfortunately, significative amounts of boilerplate code must still be written to accomplish the required interoperability. In addition, such approaches often are not amenable to custom context-dependent reification of objects in the logic world and custom mappings of arbitrary logic terms to objects in the object-oriented world. Furthermore, in the specific case of Prolog-Java integration, existing solutions are often compatible with only a single or a restricted set of Prolog engines and thus suffer from portability issues.
To address these problems, we introduce a portable framework, relying on linguistic integration, for transparently and (semi-)automatically enabling communication between routines in these two worlds, as well as a simple mechanism for customising how native artefacts in one language should be reified in the other language. We validate our approach with case studies requiring a seamless integration of declarative programs in Prolog with libraries belonging to the Java ecosystem.
Streamlining Python Development: A Guide to a Modern Project Setup
LogicObjects
1. A Portable and Extensible Approach for Linguistic
Symbiosis between an Object-Oriented and a Logic
Programming Language
Sergio Castro
Sergio.Castro@uclouvain.be
RELEASeD LAB
Université catholique de Louvain
Belgium
1
LogicObjects
Monday 26 August 13
10. But... why Java ?
• A huge Java ecosystem.
• Emerging languages running on the JVM (e.g. Scala, Clojure, etc.).
• A large user base.
6
We recognize the
advantages of:
Monday 26 August 13
11. Outline
• JPC: a portable Java-Prolog interoperability layer.
• LogicObjects: a linguistic integration framework.
• Research status.
• Future work.
• Conclusions.
7
Monday 26 August 13
12. 8
Prolog engines
Bridge libraries
JPC drivers
JPC library
Java-Prolog
applications
Java-Prolog
frameworks
(layer coupling denoted by the
direction of the arrows)
High level architectural overview
Monday 26 August 13
13. • Attempts to facilitate the creation of hybrid Java-Prolog
applications and frameworks.
• Inspired by JPL, InterProlog and Google’s Gson libraries.
• Compatible with some popular open source Prolog engines
(XSB,YAP, SWI) and more coming soon.
• Available at the Maven central snapshot repository and
GitHub1 (currently) under the LGPL license.
9
1https://github.com/sergio-castro/
JPC: Java-Prolog connectivity
Monday 26 August 13
14. JPC features
• A portable abstraction of a Prolog virtual machine.
• A set of utilities for dealing with common Java-Prolog
interoperability problems.
• High level support for:
• Mapping between Java objects and Prolog terms.
• Dealing with object references and object serialization in
Prolog.
10
Monday 26 August 13
18. 12
Converter1 Converter2 Converter3
Dispatcher
(chain of responsibility pattern)
Converter manager
The converter manager
primitive types converters,
exception converters,
multi-valued converters,
etc.
Monday 26 August 13
19. Modularising mappings between
Java objects and Prolog terms
public class StationConverter extends JpcConverter<Station, Compound> {
public static final String STATION_FUNCTOR = "station";
@Override public Compound toTerm(Station station, Jpc context) {
return new Compound(STATION_FUNCTOR, asList(new Atom(station.getName())));
}
@Override public Station fromTerm(Compound term, Jpc context) {
String stationName = ((Atom)term.arg(1)).getName();
return new StationJpc(stationName);
}
}
13
Monday 26 August 13
20. Modularising mappings between
Java objects and Prolog terms
public class StationConverter extends JpcConverter<Station, Compound> {
public static final String STATION_FUNCTOR = "station";
@Override public Compound toTerm(Station station, Jpc context) {
return new Compound(STATION_FUNCTOR, asList(new Atom(station.getName())));
}
@Override public Station fromTerm(Compound term, Jpc context) {
String stationName = ((Atom)term.arg(1)).getName();
return new StationJpc(stationName);
}
}
13
Java type
Monday 26 August 13
21. Modularising mappings between
Java objects and Prolog terms
public class StationConverter extends JpcConverter<Station, Compound> {
public static final String STATION_FUNCTOR = "station";
@Override public Compound toTerm(Station station, Jpc context) {
return new Compound(STATION_FUNCTOR, asList(new Atom(station.getName())));
}
@Override public Station fromTerm(Compound term, Jpc context) {
String stationName = ((Atom)term.arg(1)).getName();
return new StationJpc(stationName);
}
}
13
Prolog type
Monday 26 August 13
22. Modularising mappings between
Java objects and Prolog terms
public class StationConverter extends JpcConverter<Station, Compound> {
public static final String STATION_FUNCTOR = "station";
@Override public Compound toTerm(Station station, Jpc context) {
return new Compound(STATION_FUNCTOR, asList(new Atom(station.getName())));
}
@Override public Station fromTerm(Compound term, Jpc context) {
String stationName = ((Atom)term.arg(1)).getName();
return new StationJpc(stationName);
}
}
13
Monday 26 August 13
23. Modularising mappings between
Java objects and Prolog terms
public class StationConverter extends JpcConverter<Station, Compound> {
public static final String STATION_FUNCTOR = "station";
@Override public Compound toTerm(Station station, Jpc context) {
return new Compound(STATION_FUNCTOR, asList(new Atom(station.getName())));
}
@Override public Station fromTerm(Compound term, Jpc context) {
String stationName = ((Atom)term.arg(1)).getName();
return new StationJpc(stationName);
}
}
13
Monday 26 August 13
24. Configuring a JPC context with a
custom converter
Jpc jpcContext = JpcBuilder.create()
.registerConverter(new StationConverter()).build();
14
Monday 26 August 13
25. Configuring a JPC context with a
custom converter
Jpc jpcContext = JpcBuilder.create()
.registerConverter(new StationConverter()).build();
14
Default builder
(includes pre-defined
converters)
Monday 26 August 13
26. Configuring a JPC context with a
custom converter
Jpc jpcContext = JpcBuilder.create()
.registerConverter(new StationConverter()).build();
14
Default builder
(includes pre-defined
converters)
Extending JPC with
new conversions
Monday 26 August 13
27. Querying Prolog with JPC
15
public class StationManager {
public static final Jpc jpcContext = ... //context includes StationConverter
...
public Station mainStation() {
String stationVarName = "Station";
Term goal = new Compound("main_station", asList(new Variable(stationVarName)));
Query query = getPrologEngine().query(goal, jpcContext);
return query.<Station>selectObject(stationVarName).oneSolutionOrThrow();
}
}
Monday 26 August 13
28. Querying Prolog with JPC
15
public class StationManager {
public static final Jpc jpcContext = ... //context includes StationConverter
...
public Station mainStation() {
String stationVarName = "Station";
Term goal = new Compound("main_station", asList(new Variable(stationVarName)));
Query query = getPrologEngine().query(goal, jpcContext);
return query.<Station>selectObject(stationVarName).oneSolutionOrThrow();
}
}
main_station(Station)
Monday 26 August 13
29. Querying Prolog with JPC
15
public class StationManager {
public static final Jpc jpcContext = ... //context includes StationConverter
...
public Station mainStation() {
String stationVarName = "Station";
Term goal = new Compound("main_station", asList(new Variable(stationVarName)));
Query query = getPrologEngine().query(goal, jpcContext);
return query.<Station>selectObject(stationVarName).oneSolutionOrThrow();
}
}
Monday 26 August 13
30. Querying Prolog with JPC
15
public class StationManager {
public static final Jpc jpcContext = ... //context includes StationConverter
...
public Station mainStation() {
String stationVarName = "Station";
Term goal = new Compound("main_station", asList(new Variable(stationVarName)));
Query query = getPrologEngine().query(goal, jpcContext);
return query.<Station>selectObject(stationVarName).oneSolutionOrThrow();
}
}
binding of Station as a Java object
Monday 26 August 13
31. Dealing with object references
@Test
public void testJRef() {
Object o = new Object();
Term jRef = RefManager.jRefTerm(o);
assertTrue(o == jpc.fromTerm(jRef));
o = null;
System.gc();
try {
jpc.fromTerm(jRef);
fail();
} catch(RuntimeException e) {}
}
16
Monday 26 August 13
32. Dealing with serialized objects
@Test
public void testSerializedTerm() {
String s = "hello";
Term term = SerializedObject.serializedObjectTerm(s);
String s2 = jpc.fromTerm(term);
assertFalse(s == s2);
assertEquals(s, s2);
}
17
Monday 26 August 13
35. JPC as a library for implementing
Java-Prolog frameworks
20
Prolog engines
Bridge libraries
JPC drivers
JPC library
Java-Prolog
applications
Java-Prolog
frameworks
(layer coupling denoted by the
direction of the arrows)
Monday 26 August 13
36. JPC as a library for implementing
Java-Prolog frameworks
20
Prolog engines
Bridge libraries
JPC drivers
JPC library
Java-Prolog
applications
Java-Prolog
frameworks
(layer coupling denoted by the
direction of the arrows)
e.g. LogicObjects
Monday 26 August 13
37. LogicObjects
• A portable Java-Prolog linguistic symbiosis framework.
• Implemented on top of the JPC library.
• Provides obliviousness concerning integration (in common
scenarios).
• Based on annotations for customising the integration and
minimising programming effort.
21
Monday 26 August 13
38. Symbiosis
22
“The intimate living together of two dissimilar organisms in a
mutually beneficial relationship.” (Merriam-Webster dictionary)
Monday 26 August 13
39. Linguistic symbiosis
• Objects from different worlds must understand each other.
• Invoking routines from another language as if they were defined
in their own language.
23
• Easier to achieve if the
languages belong to the
same paradigm.
Monday 26 August 13
40. A paradigm leak
“The event of concepts leaking from one programming paradigm
to another”
24
* Brichau, J. et al.
Towards linguistic symbiosis of an object-oriented and a logic
programming language.
In Proceedings of the Workshop on Multiparadigm Programming with Object-
Oriented Languages. (2002)
*
Monday 26 August 13
41. The inhabitants of our two
worlds
25
The OO
world
The logic
world
Monday 26 August 13
42. The inhabitants of our two
worlds
25
Classes
Objects
Messages
Methods
Return values
Packages The OO
world
The logic
world
Facts
Rules
Terms
Queries
Query solutions
Modules
Monday 26 August 13
43. Reducing the gap with Logtalk
26
The OO
world
The logic
world
Monday 26 August 13
44. Reducing the gap with Logtalk
26
The OO
world
The logic
world
Logtalk
An object-oriented layer
Monday 26 August 13
57. Invoking a Logtak method
Messages in Logtalk are expressed with the :: operator.
For example:
line(central)::connects(Station1, Station2)
Answers all the stations connected by the line ‘central’
32
Monday 26 August 13
58. Invoking a Logtak method
Messages in Logtalk are expressed with the :: operator.
For example:
line(central)::connects(Station1, Station2)
Answers all the stations connected by the line ‘central’
32
Monday 26 August 13
60. The Java world
34
public abstract class Line {
String name;
public Line(String name) {this.name = name;}
public abstract boolean connects(Station s1, Station s2);
public abstract int segments();
}
public abstract class Station {
...
}
public abstract class Metro {
...
}
Monday 26 August 13
61. The Java world
34
public abstract class Line {
String name;
public Line(String name) {this.name = name;}
public abstract boolean connects(Station s1, Station s2);
public abstract int segments();
}
public abstract class Station {
...
}
public abstract class Metro {
...
}
@LObject(args={“name”})
@LMethod(name={“connects”}, args={“_”, “_”})
@LObject(args={“name”})
Monday 26 August 13
62. Linguistic symbiosis challenges
• Translating objects to logic terms (and back).
• Mapping OO methods to logic queries.
• Dealing with unbound variables.
• Returning values from queries.
• Managing multiplicity.
35
* Some of them presented a bit differently in:
D'Hondt, M. et al.
Seamless integration of rule-based knowledge and object-
oriented functionality with linguistic symbiosis.
In Proceedings of the 2004 ACM symposium on Applied computing.
(2004)
*
Monday 26 August 13
63. public abstract class Metro {...}
@LObject(name = "my_metro")
public abstract class Metro {...}
@LObject(args = {"name"})
public abstract class Line {
private String name;
...
}
metro
my_metro
line(lineName)
Translating objects to logic terms
36
Java Prolog
Monday 26 August 13
64. public abstract class Metro {...}
@LObject(name = "my_metro")
public abstract class Metro {...}
@LObject(args = {"name"})
public abstract class Line {
private String name;
...
}
metro
my_metro
line(lineName)
Translating objects to logic terms
36
Java Prolog
Monday 26 August 13
65. public abstract class Metro {...}
@LObject(name = "my_metro")
public abstract class Metro {...}
@LObject(args = {"name"})
public abstract class Line {
private String name;
...
}
metro
my_metro
line(lineName)
Translating objects to logic terms
36
Java Prolog
Monday 26 August 13
66. public abstract class Metro {...}
@LObject(name = "my_metro")
public abstract class Metro {...}
@LObject(args = {"name"})
public abstract class Line {
private String name;
...
}
metro
my_metro
line(lineName)
Translating objects to logic terms
36
Java Prolog
Monday 26 August 13
67. line(lName)::connects(
station(s1Name), station(s2Name)).
line(lName)::connects(_, _).
Mapping Java methods to Logtalk
methods
37
@LObject(args = {"name"})
public abstract class Line {
private String name;
public abstract
boolean connects(Station s1, Station s2);
@LMethod(name = "connects", args = {"_", "_"})
public abstract
int segments();
}
Java Prolog
Monday 26 August 13
68. line(lName)::connects(
station(s1Name), station(s2Name)).
line(lName)::connects(_, _).
Mapping Java methods to Logtalk
methods
37
@LObject(args = {"name"})
public abstract class Line {
private String name;
public abstract
boolean connects(Station s1, Station s2);
@LMethod(name = "connects", args = {"_", "_"})
public abstract
int segments();
}
Java Prolog
Monday 26 August 13
69. line(lName)::connects(
station(s1Name), station(s2Name)).
line(lName)::connects(_, _).
Mapping Java methods to Logtalk
methods
37
@LObject(args = {"name"})
public abstract class Line {
private String name;
public abstract
boolean connects(Station s1, Station s2);
@LMethod(name = "connects", args = {"_", "_"})
public abstract
int segments();
}
Java Prolog
Monday 26 August 13
70. line(lName)::connects(
station(s1Name), station(s2Name)).
line(lName)::connects(_, _).
Mapping Java methods to Logtalk
methods
37
@LObject(args = {"name"})
public abstract class Line {
private String name;
public abstract
boolean connects(Station s1, Station s2);
@LMethod(name = "connects", args = {"_", "_"})
public abstract
int segments();
}
Java Prolog
anonymous variables
Monday 26 August 13
71. 38
Interpreting a query result as a
Java object
The logic solutions
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
Monday 26 August 13
72. 38
Interpreting a query result as a
Java object
The logic solutions
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
(set of frames binding logic
variables to terms)
frame 1
frame 2
frame n
Monday 26 August 13
73. 39
Interpreting a query result as a
Java object
The logic solutions
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
(set of frames binding logic
variables to terms)
Monday 26 August 13
74. 39
Interpreting a query result as a
Java object
The logic solutions The method return value
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
aJavaObject
Varxn xn, Varyn yn
(set of frames binding logic
variables to terms)
Monday 26 August 13
75. 40
The logic solutions
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
(set of frames binding logic
variables to terms)
Returning values from one
solution
Monday 26 August 13
76. 40
The logic solutions The method return value
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
aJavaObject
Varxn xn, Varyn yn
(set of frames binding logic
variables to terms)
Returning values from one
solution
Monday 26 August 13
77. 41
Returning values from one
solution
The logic solutions The method return value
term(Varx1, Vary1)
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
(set of frames binding logic
variables to terms)
Monday 26 August 13
78. 41
Returning values from one
solution
The logic solutions The method return value
term(Varx1, Vary1)
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
(set of frames binding logic
variables to terms)
(specified in a method
with @LSolution)
Monday 26 August 13
79. 41
Returning values from one
solution
The logic solutions The method return value
term(Varx1, Vary1)
Varx1 x1, Vary1 y1 term(x1, y1)
Varx2 x2, Vary2 y2 term(x2, y2)
Varxn xn, Varyn yn term(xn, yn)
(set of frames binding logic
variables to terms)
(specified in a method
with @LSolution)
(default solution)
Monday 26 August 13
80. 42
Explicit specification of return
values
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
Monday 26 August 13
81. 42
Explicit specification of return
values
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
Monday 26 August 13
82. • Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
Monday 26 August 13
83. first Java method parameter
• Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
Monday 26 August 13
84. first Java method parameter
• Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
unbound
Prolog variable
(as term)
Monday 26 August 13
85. • Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
Monday 26 August 13
86. • Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
(instance of)
Monday 26 August 13
87. station(b)::reachable(station(a), IStations)
• Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
Monday 26 August 13
88. station(b)::reachable(station(a), IStations)
• Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
Monday 26 August 13
89. station(b)::reachable(station(a), IStations)
• Preprocessing macros and Java exp.
• Convert arguments to terms.
• Convert method to a predicate.
• Convert receiver object to a term.
• Build a query.
• Determine solution heuristic.
• Convert solution terms back to objects.
43
• $1 => station (method parameter).
• (station(a), IStations)
• intermediateStations => reachable/2.
• station(b)
• station(b)::reachable(station(a), IStations)
• Binding of IStations (first solution).
• [station(x), station(y)] => List<Station>
Processing Steps Outcome
@LObject(args = {"name"})
public abstract class Station {
@LSolution("IStations")
@LMethod(name = "reachable", args = {"$1", "IStations"})
public abstract List<Station> intermediateStations(Station station);
...
}
Monday 26 August 13
90. 44
Returning multiple values from
queries
The logic solutions The method return value
term(Varx1, Vary1)
Varx1 x1, Vary1 y1 term(x1, y1)
Varx2 x2, Vary2 y2 term(x2, y2)
Varxn xn, Varyn yn term(xn, yn)
Monday 26 August 13
91. 44
Returning multiple values from
queries
The logic solutions The method return value
term(Varx1, Vary1)
Varx1 x1, Vary1 y1 term(x1, y1)
Varx2 x2, Vary2 y2 term(x2, y2)
Varxn xn, Varyn yn term(xn, yn)
a composed solution
(specified in a method
with @LComposition)
Monday 26 August 13
92. 45
The logic solutions The method return value
(a property of the result set)
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
Returning a property of the result
set
}
Monday 26 August 13
93. 45
The logic solutions The method return value
(a property of the result set)
Varx1 x1, Vary1 y1
Varx2 x2, Vary2 y2
Varxn xn, Varyn yn
is there a solution ?
Returning a property of the result
set
how many solutions ?
}
Monday 26 August 13
94. Returning a property of the result
set
46
@LObject(args = {"name"})
public abstract class Line {
private String name;
public abstract
boolean connects(Station s1, Station s2);
@LMethod(name = "connects", args = {"_", "_"})
public abstract
int segments();
}
Monday 26 August 13
95. Returning a property of the result
set
46
@LObject(args = {"name"})
public abstract class Line {
private String name;
public abstract
boolean connects(Station s1, Station s2);
@LMethod(name = "connects", args = {"_", "_"})
public abstract
int segments();
}
should return if logic method succeeds or not
Monday 26 August 13
96. Returning a property of the result
set
46
@LObject(args = {"name"})
public abstract class Line {
private String name;
public abstract
boolean connects(Station s1, Station s2);
@LMethod(name = "connects", args = {"_", "_"})
public abstract
int segments();
}
should return if logic method succeeds or not
should return the number of solutions
Monday 26 August 13
97. Instantiating a symbiotic object in
Java
Line line = newLogicObject(Line.class, “central”);
System.out.println("Number of segments of line " + line + ": " + line.segments());
47
Monday 26 August 13
98. Instantiating a symbiotic object in
Java
Line line = newLogicObject(Line.class, “central”);
System.out.println("Number of segments of line " + line + ": " + line.segments());
47
Monday 26 August 13
99. Instantiating a symbiotic object in
Java
Line line = newLogicObject(Line.class, “central”);
System.out.println("Number of segments of line " + line + ": " + line.segments());
47
Monday 26 August 13
100. Other features
• Java expressions embedded in logic terms (symbiosis terms).
• Dependency management support.
• Integration with plain Prolog (without Logtalk).
• Not constrained to a specific execution environment (e.g. an
Eclipse plugin).
48
Monday 26 August 13
101. Inspiration from other domains
• Common interoperability layer: JDBC.
• Mapping artefacts using annotations: JAXB.
• Context dependent conversions: GSON.
• Linguistic symbiosis concepts: SOUL.
49
1http://www.oracle.com/technetwork/java/javase/jdbc/
2https://jaxb.java.net/
3http://code.google.com/p/google-gson/
4http://soft.vub.ac.be/SOUL/
1
2
3
4
Monday 26 August 13
102. implemented
pending
if time allows it
• Integration direction
• OO to Prolog
• Prolog to OO
• Linguistic symbiosis
• Automation
• Transparency
• Customisation
• Preserving causality
• Inter-language reflection
• Code querying
• Code transformation
• Code generation
• Symbiotic inter-language reflection
• Portability
Research status
50
Monday 26 August 13
103. Future work
• Finishing a full bidirectional linguistic symbiosis framework.
• Exploring the feasibility of our approach for symbiotic inter-
language reflection.
• Adding support for more Prolog engines (e.g. an embedded
one).
• Continue the development of reusable hybrid components.
51
Monday 26 August 13
104. Conclusions
• We are actively exploring how far we can get in automation/
transparency regarding Java-Prolog linguistic integration.
• We are attempting to provide reusable hybrid components
and frameworks that may be helpful to the community.
• And we are trying to do this in a portable way.
52
Monday 26 August 13