a portable approach for bidirectional integration between a logic and a statically-typed...

Université catholique de Louvain Information and Communication Technologies,

Electronics and Applied Mathematics

Public Defense!!

Sergio CASTRO MEJIA Master of Science in Computer Science

For Obtaining the Degree of PhD in Engineering Sciences, Computer Science!

:- object(phd_thesis).!!! :- info([!! ! author is 'Sergio Castro',!! ! date is '8th of September 2014']).!!!! title('A Portable Approach for Bidirectional Integration!between a Logic and a Statically-Typed Object-Oriented Programming Language').!!!! advisor ('Prof. Kim Mens', 'UCL', 'Belgium').!!! chairman('Prof. Charles Pecheur','UCL', 'Belgium').!!! jury ('Prof. Anthony Cleve', 'UNamur', 'Belgium').!!! jury ('Prof. Paul Tarau', 'University of North Texas',! 'USA').!!! jury ('Dr. Jan Wielemaker', 'Vrije Universiteit Amsterdam', !! ! 'The Netherlands').!! !:- end_object.!

:- object(content).!!! section(1, 'Motivation').!!! section(2, 'An Integration Framework Architecture').!!! section(3, 'Context-Dependent Inter-Language Conversions').!!! section(4, 'Integration from the OO Language Perspective').!!! section(5, 'Integration from the Logic Language Perspective').!!! section(6, 'Conclusions and Future Work').!!:- end_object.!

Subliminal message!A logic program is extremely

intuitive to understand

Motivation

?- content::section(Part,Desc).!Part = 1,!Desc = 'Motivation';

Enabling the Interaction between the Inhabitants of Different Worlds

A smooth interaction is often difficult to accomplish.

!Classes!

Packages!Objects!Fields!

Methods!Return values!

!Modules!Terms!Facts!Rules!

Queries!Query solutions!

The OO world The Logic world

Enabling the Interaction between the Inhabitants of Different Worlds

Object-Oriented vs Logic Programming

The decomposition of a system is based upon the notion of objects.

A program is conceived as a logic theory.

class Person {!!! String name;!!! double temperature;!!! boolean hasFever() {!! ! return temperature>38;!! }!!}

person(peter).!!temperature(peter,39).!!has_fever(X) :- person(X),! temperature(X,N),! N>38.

Classes model a family of objects Facts

Object-Oriented and Logic Languages are equivalent in power.

They both have the expressive power of a Turing Machine.

Appropriate for modelling real-world concepts

Rich general-purpose software ecosystem

Logic programming software ecosystem

Declarative reasoning, knowledge-intensive systems

OO programming

Logic programming

But they are not equivalent in their ease of expression.

OO programming

Logic programming

Multi-Paradigm programming

OO programming

Logic programming

Multi-Paradigm Programming

languages

Inter-Operability approachesvs.

- Only one (complex) language is required.

- A mature software ecosystem is not always available.

- Distinct languages belonging to different paradigms.

- Complex mapping of concepts. - Reuse of existing software

ecosystems. !

Both present advantages and limitations

A Hybrid System Example

</node>

</osm>

Pre-processing raw data (e.g., converting it

into a logic theory).

Logic LanguageOO Language OO Language

Querying, analysing and/or transforming

the data.

Post-processing the data (e.g.,

displaying it, distributing query results, etc.).

Related Work

Obliviousness from the logic perspective Obliviousness from

the OO perspective

Obliviousness

Common Inter-Operability Problems

Explicit boilerplate integration code

Integration-code tangled with the main

programming concern

“Let us make a special effort to stop communicating with each other, so we can have some conversation.”

—Mark Twain

Oblivious Integration

Objects from different worlds must understand each other without effort. (e.g., invoking routines from the foreign language as if they were defined

in the native language).

Oblivious integration is already complex to achieve if the languages belong to the same paradigm

Integrating Same-Paradigm Languages

A Paradigm Mismatch

… but it is even harder if some concepts in one language do not straightforwardly match in the other.

Limitations of Oblivious Integration Approaches between OO and Logic Languages

Strong architectural assumptions (e.g., assuming the logic

program runs embedded in the OO programming environment).

Lack of customisability (e.g., difficult to switch between

integration policies).

Compromises portability.

Compromises applicability.

Proposed Approach

Oblivious language integration as a portable and customisable language-interoperability technique for achieving multi-paradigm programming.

VisionTo provide a conceptual framework and its corresponding implementation that simplifies the creation of hybrid systems composed of both logic and statically-typed object-oriented code.

… or declaratively specified

Integration aspects should be

automatically inferred

Why a Statically-Typed Language?

The additional type data provided by statically-typed languages makes them more amenable to integration techniques based on static analysis.

An Integration Framework Architecture

?- content::section(Part,Desc).!Part = 2,!Desc = 'An Integration Framework Architecture';

Java and Prolog as our Target Languages

Java guarantees portability and deployability

Prolog facilitates the exploitation of decades of

research in logic programming

Abstract architectural view

JVM abstraction

Drivers

PVM abstraction

Java program

Prolog integrationframework

Prolog program

Java integrationframework

JVM abstraction

Drivers

PVM abstraction

Java program

Prolog program

JVM abstraction

Drivers

PVM abstraction

Java program

Prolog program

The Inhabitants of Our Two Worlds

!Classes!

Packages!Objects!Fields!

Methods!Return values!

! The OO world

The Logic world

!Modules!Terms!Facts!Rules!

Queries!Query solutions!

The Logic world

An OO layer

Reducing the Paradigm Mismatch

LogtalkAn Object-Oriented Layer

PrototypesClasses

Methods

Inheritance

Protocols

Categories

Encapsulation

TermsFactsRules

QueriesQuery Solutions

The Logic World

Reducing the Paradigm Mismatch with Logtalk

Concrete architectural view

Logtalk

JPC Drivers

Java program

LogicObjects

Prolog/Logtalk program

LogicObjects

JVM abstraction

Drivers

PVM abstraction

Java program

Prolog program

Concrete architectural view

Logtalk

JPC Drivers

Java program

LogicObjects

Transparent integration by means of (semi-) automatic

mappings between artefacts.

Relies on advanced reflection techniques (e.g., runtime code

generation and byte-code instrumentation).

Logtalk

JPC Drivers

Java program

LogicObjects

Java-Prolog Connectivity (JPC)

Abstracts a Prolog VM in the Java world and a Java VM in the

Prolog world.

Framework for context-dependent inter-language

conversion of artefacts.

Logtalk

JPC Drivers

Java program

LogicObjects

JPC Drivers

Logtalk

JPC Drivers

Java program

LogicObjects

Concrete Prolog engines

Engine-specific drivers

JPLPDT InterProlog

SWI XSBYAP

Context-Dependent Inter-Language Conversions

?- content::section(Part,Desc).!Part = 3,!Desc = 'Context-Dependent Inter-Language Conversions';

To provide a customisable framework for the inter-language conversion of artefacts.

GoalJava world

Prolog world

Objects !(e.g., a String)!

and primitive types!(e.g., an int, float, char, etc.)

compound!(e.g., student(‘name’))

atom!(e.g., ‘hello’)

integer!(e.g., 4)

float!(e.g., 4.0)

variable!(e.g., Var)

Context Matters

The right conversion is often context-dependent

new Person(“name”)

person(‘name’)

‘name’

context A

context B

Java world

Prolog world

The Conversion Context

A conversion context encapsulates a bi-directional

conversion policy.

JPC //default context builder JpcBuilder builder = JpcBuilder.create(); !//default conversion context Jpc jpc = builder.build();

Pre-Defined Catalog of Converters

String helloString = jpc.fromTerm(new Atom(“hello”)); Atom helloAtom = jpc.toTerm(helloString); boolean bool = jpc.fromTerm(new Atom(“true”)); Atom trueAtom = jpc.toTerm(bool);

JPC pre-defines a default catalog of converters (primitives, multi-valued, exceptions, etc).

Some primitive conversions:

Type-Guided Conversions

String trueString = jpc.fromTerm(new Atom(“true”), String.class); int i = jpc.fromTerm(new Atom(“1”), int.class); Atom atom = jpc.toTerm(i, Atom.class);

the atom ‘true’ should not be interpreted as a boolean, but as a string

the atom ‘1’ should not be interpreted as a string, but as an int

the int 1 should not be interpreted as an integer term,

but as an atom

Defining Custom Converters

public class StationConverter implements ToTermConverter <Station , Compound>, FromTermConverter <Compound , Station > { public static final String STATION_FUNCTOR = "station"; ! @Override public Compound toTerm(Station station, Class<Compound> termClass, Jpc context) { return new Compound(STATION_FUNCTOR , asList(new Atom(station.getName()))); } ! @Override public Station fromTerm(Compound term, Type type, Jpc context) { String stationName = ((Atom)term.arg(1)).getName(); return new Station(stationName); } }

Registering Converters

//custom context builder JpcBuilder builder = JbcBuilder.create().register(new StationConverter()); !//custom conversion context Jpc jpc = builder.build();

registering the custom converter StationConverter

Registering Converters for Specific Terms

//custom context builder JpcBuilder builder = JbcBuilder.create(); !//targetTerm = hello(_) Term targetTerm = new Compound(“hello”, asList(Var.ANONYMOUS_VAR)); !builder.register(new HelloConverter(), targetTerm); !//custom conversion context Jpc jpc = builder.build();

registering the HelloConverter as able to convert terms

of the form hello(_)

A Categorisation of Converters

Animal

Object

converter =AnimalConverter

<Animal,Compound>

HasLegsFurry

FourLegged

converter = HasLegsConverter

<HasLegs,Compound>

Resolving Converters by Means of Linearisation

converter = HasLegsConverter

<HasLegs,Compound>

converter =AnimalConverter

<Animal,Compound>

FourLegged

Animal

Object HasLegsFurry

Integration from the OO Language Perspective

?- content::section(Part,Desc).!Part = 4,!Desc = 'Integration from the OO Language Perspective';

Case Study I!The London Underground

Relevant Concepts

stations

linesmetro

Nearby: At most one intermediate station,! in the same line (e.g., A with C).

Interesting Relations

line1A C

Connected: Directly connected (e.g., A with B).!

Reachable: Transitively connected (e.g., A with F).

connected nearbyreachable

Interesting Relations

Easily expressed with logic facts and rules

Nearby: At most one intermediate station,! in the same line (e.g., A with C).

Connected: Directly connected (e.g., A with B).!

Reachable: Transitively connected (e.g., A with F).

A Rule Based System Using Prolog

!! ! connected(station(bond_street), station(oxford_circus), line(central)). connected(station(oxford_circus), station(tottenham_court_road), line(central)). ... ! nearby(S1,S2) :- connected(S1,S2,_). nearby(S1,S2) :- connected(S1,S3,L), connected(S3,S2,L).! reachable(S1,S2,[]) :- connected(S1,S2,_). reachable(S1,S2,[S3|Ss]) :- connected(S1,S3,_), reachable(S3,S2,Ss).! line(Name) :- setof(L, S1^S2^connected(S1,S2,L), Ls), list::member(line(Name), Ls).

Adding an OO Layer with Logtalk

!! ! connected(station(bond_street), station(oxford_circus), line(central)). connected(station(oxford_circus), station(tottenham_court_road), line(central)). ... ! nearby(S1,S2) :- connected(S1,S2,_). nearby(S1,S2) :- connected(S1,S3,L), connected(S3,S2,L).! reachable(S1,S2,[]) :- connected(S1,S2,_). reachable(S1,S2,[S3|Ss]) :- connected(S1,S3,_), reachable(S3,S2,Ss).! line(Name) :- setof(L, S1^S2^connected(S1,S2,L), Ls), list::member(line(Name), Ls).

:- object(metro).

:- end_object.

:- public([connected/3, nearby/2, reachable/3, line/1]). ACCESS MODIFIERS

Logtalk Parametric Objects

:- object(line(_Name)).! :- public([name/1, connects/2]). name(Name) :- parameter(1, Name). ... !:- end_object.!!:- object(station(_Name)).! :- public([name/1, connected/2, nearby/1, reachable/2]). name(Name) :- parameter(1, Name). ... !:- end_object.

PARAMETRIC OBJECT

Invoking a Logtalk 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’.

The Java World

!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 { ...}

Declarative Mapping by Means of Annotations

• @LObject: Map class instances to Logtalk objects.

• @LMethod: Map methods to Logtalk predicates.

• @LSolution: Map a single solution to a method return value.

• @LComposition: Maps a set of solutions to a method return value.

!!!!!!!metro!!!!!!!!!line(‘line_name’)

!!!!@LObject(name = "metro")public abstract class Metro {...}!Metro aMetro = …;!!!@LObject(name = "line", args = {"name"})public abstract class Line { private String name; ...}!Line aLine = …;!

Converting Java Objects to Prolog Terms

Java Prolog

Mapping Java Methods to Logtalk Methods

metro- line/1- connected/3- nearby/2- reachable/3

line/1- connects/2

station/1- connected/2- nearby/1- reachable/2

Line- boolean connects(Station s1, Station s2)- int segments()

Station- Station connected(Line l)- List<Station> nearby()- List<Station> intermediteStations(Station s)

The Java world The Logtalk world

Metro- List<Line> lines()- Line line(String s)

Default and Custom Mappings of Java Methods to Logtalk Methods

!!!!!!!line(lName)::connects( station(s1Name), station(s2Name)).!!line(lName)::connects(_, _).

@LObject(name = "line", 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

Interpreting a Query Solution as a Java Object

The logic solutions

Varx1 x1, Vary1 y1Varx2 x2, Vary2 y2

Varxn xn, Varyn yn(set of frames binding logic

variables to terms)

frame 1frame 2

frame n

Interpreting a Query Solution as a Java Object

The logic solutions The method return value

aJavaObject

variables to terms)

one solution?

all solutions?

a property of the result set?

Interpreting One Query Solution as a Java Object

aJavaObjectVarx1 x1, Vary1 y1Varx2 x2, Vary2 y2

variables to terms)

Interpreting One Query Solution as a Java Object

termVarx1 x1, Vary1 y1Varx2 x2, Vary2 y2

variables to terms)

aJavaObject

•Preprocessing macros.

•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.

station(b)::reachable(station(a), IStations)first Java method parameter

• $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(name = "station", 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)

(instance of)

Returning Multiple Values from Queries

@LObject(name = “station”, args = {"name"})public abstract class Station { ... @LComposition @LSolution("S") @LMethod(args = {"S"}) public abstract List<Station> nearby();}

each solution type

container type

!!!!!station(aName)::nearby(S).!!

LogtalkJava

Returning a Property of the Result Set

variables to terms)

(a property of the result set)

is there a solution ?

how many solutions ?}

Returning a Property of the Result Set

@LObject(name = "line", 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(); }!!!

returns if the query succeeds or not

returns the number of solutions

Integration from the Logic Language Perspective

?- content::section(Part,Desc).!Part = 5,!Desc = 'Integration from the Logic Language Perspective';

Automatic Delegation to the Java World

Prolog

an_object

jobject jpc anObject

logtalk_message

javaMessage

Any message not understood by an object importing the jobject category will be automatically delegated to the Java world.

:- object(an_object ,! imports(jobject)).!! ...!:- end_object.!

Mapping a Logtalk Method to a Java Method

an_object::message(arg1,… argN, return(ReturnSpecifier))

object.message(arg1,… argN)

Prolog worldJava world

return value

Return Specifiers

term(Result)

jref(Result)

strong(jref(Result))

weak(jref(Result))

soft(jref(Result))

strong(jref_term(Result))

weak(jref_term(Result))

soft(jref_term(Result))

serialized(Result)

Return specifiers denote how a method return value should be

interpreted and represented

Alternative Mechanisms to Capture the Return Value

an_object::message(arg1,… argN) return ReturnSpecifier.

jobject(Expression, ReturnSpecifier)::message(arg1,… argN)

As an argument of the receiver

Using the return operator

an_object::message(arg1,… argN, return(ReturnSpecifier))

As an argument of the method

(a,b)!(sequence)

‘java.lang.String’(‘hello’)!(constructor)

(x,y)::a!(broadcasting)

obj::method!(method call)

x::(a,b)!(cascading)

x::[a]!(accessors)

Terms reifying Java expressions

x::[a,v]!(mutators)

Case Study II!The MapQuery Application

Map Query Information Flow

Converting OSM raw data into a logic theory.

Displaying the queried data.

Querying geographical data.

PrologJava Java<osm version="0.6" generator="CGImap 0.0.2">

</node>

</osm>

Relevant Entities

Coordinates!A place in a map

identified by a latitude and longitude.

Nodes!Points of

interest in the map having a coordinate.

Ways!Collections of nodes

(e.g.,streets).

Tags!Named

properties of nodes and ways.

Java Classes

MapBrowser

- void goTo(Coordinates)- void zoomTo(Integer)- void draw(Taggable)- void draw(List<Taggable>)…

Coordinates

- double getLon()- double getLat()

- Long getId()…

Taggable

- Map<String, String> getTags()

Logtalk Objects

84Entities Diagram for the MapQuery Example

mapquery_lib

coordinates.lgt

taggable.lgt

osm.lgt

node.lgtway.lgt

(external entities)

coordinates(Lon,Lat)prototype

lon/1lat/1

distancekm/2distancem/2

near/2

taggable(Tags)category

tags/1tag/2

has_tags/1

listprototype

osmprototype

node/3node/2node/1

number_nodes/1way/3way/2way/1

number_ways/1

node(Id,Coordinates,Tags)prototype

id/1coordinates/1distancekm/2

near/2

imports

way(Id,Nodes,Tags)prototype

id/1nodes_ids/1nodes/1node/1

distancekm/2near/2

importsuses

Navigating the Map Browser

class('…MapBrowserStage')::launch return weak(jref(Map))

Invoking the launch static method on the

MapBrowserStage class

Map unifies with a (weak) reference to the

map browser

Map::zoomTo(int(14)), !city(brussels)::coordinates(BRU), !Map::goTo(BRU)

Zooming-in the map

Obtaining the coordinates of

Brussels Moving the map to

Brussels

Drawing on the Map

osm::node(Node), !Node::has_tags([railway-station]), !Node::has_tags(['name:fr'-'Bruxelles -Central']), !Node::coordinates(Coordinates), !osm::way(Way), !Way::near(Coordinates , 0.1), !Map::draw([Node, Way]). !

Node is “Brussels

Central Station”

Coordinates are the coordinates of

the node

Way is a way within 100 meters from

the nodeDraw the Node and

Drawing on the Map

osm::node(Node), !Node::has_tags([railway-station]), !Node::has_tags(['name:fr'-'Bruxelles -Central']), !Node::coordinates(Coordinates), !osm::way(Way), !Way::near(Coordinates , 0.1), !Map::draw([Node, Way]). !

MapBrowser

- void goTo(Coordinates)- void zoomTo(Integer)- void draw(Taggable)- void draw(List<Taggable>)…

Brussels Central Station

OSM “ways” close to the

station

Conclusions and Future Work

?- content::section(Part,Desc).!Part = 6,!Desc = 'Conclusions and Future Work';

Conclusions• We provide a conceptual model of a bidirectional oblivious integration

between a logic and a statically-typed OO language.

• Our model was instantiated for Java and Prolog.

• Static-type analysis was used to infer in certain cases the best integration strategy.

• Strong focus on portability: our libraries are not constrained to a specific execution environment on the Java-side (e.g., an IDE plugin) or Prolog-side (e.g., requiring an embedded logic engine).

• Compatible with several open-source Prolog engines by means of drivers.

• Our implementation is, and will remain, open-source software.

Supporting Publications• Automatic Integration of Hybrid Java-Prolog Entities with LogicObjects.

Sergio Castro, Kim Mens and Paulo Moura. To appear in the Association for Logic Programming (ALP) Newsletter. Out of Left Field track. September Issue. 2014.

• JPC: A Library for Categorising and Applying Inter-Language Conversions Between Java and Prolog.Sergio Castro, Kim Mens and Paulo Moura. Submitted to Science of Computer Programming: Experimental Software and Toolkits (EST 6).

• Customisable Handling of Java References in Prolog Programs.Sergio Castro, Kim Mens and Paulo Moura. Proceedings of the International Conference on Logic Programming (ICLP 2014).

• LogicObjects: A Portable and Extensible Approach for Linguistic Symbiosis between an Object-Oriented and a Logic Programming Language.Sergio Castro. Proceedings of the International Conference on Logic Programming, Doctoral Consortium (ICLP DC 2013).

• LogicObjects: Enabling Logic Programming in Java through Linguistic Symbiosis.Sergio Castro, Kim Mens and Paulo Moura. Proceedings of the 15th International Symposium on Practical Aspects of Declarative Languages (PADL 2013).

• LogicObjects : A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java.Sergio Castro, Kim Mens and Paulo Moura. Proceedings of the 9th ECOOP Workshop on Reflection, AOP, and Meta-Data for Software Evolution (RAM-SE 2012).

Supporting Research Artefacts!• Java–Prolog Connectivity (JPC).

A Java-Prolog integration library inspired by Google’s Gson. http://java-prolog-connectivity. github.com/.

• LogicObjects.A linguistic integration framework for Java and Prolog. https://github.com/java-prolog-connectivity/logicobjects/.

• JConverter.A Java framework to encapsulate, categorise and apply type-guided conversions between objects. http://jconverter. github.com/.

• JGum.A lightweight categorisation framework for Java. http://jgum. github.com/.

https://github.com/sergio-castro/ Follow/fork me at

“Talking is cheap. Show me the code.” — Linus Torvalds

Future Work• Inter-language reflection support (reflecting Java

programs from Prolog).

• Refactoring, transforming, mining, analysing & querying tools for Java programs and other artefacts.

• Improving performance.

• Development of native drivers.

• Support for additional logic engines.

Thank you

These slides!http://www.slideshare.net/SergioCastro25/sergio-castro-

phdpublicdefense

PhD thesis!http://www.info.ucl.ac.be/~sergio/files/publications/2014-phd-

castro.pdf

Pointers

My website!http://www.info.ucl.ac.be/~sergio/

a portable approach for bidirectional integration between a logic and a statically-typed...

Science

the easy-peasy-lemon-squeezy, statically-typed, purely...

implementing statically typed object-oriented programming

java virtual machine guide · escape analysis 5-5 6 jvm...

the algorithm mannot for coq extraction to statically...

spreadshirt philipp hauer, fabian sudau - jug saxony...

java reloaded - deniz oguz€¦ · java, c, scala are...

on to python 3 -...

bidirectional elaboration of dependently typed...

gergo erdi - compositional type checking · 2015. 3....

xduce: a statically typed xml processing language

aod-thorn: an extension of thorn with the aspect-oriented...

prolac: a language for protocol...

adding dynamically-typed language support to a...

beams: statically indeterminate statically indeterminate

elegance of kotlin anton bannykh jetbrains · kotlin...

objects, encapsulation,...

© 2012 ibm corporation on the benefits and pitfalls of...

efficient implementations of machine vision …...statically...

querydsl - reference documentation · querydsl 4.0.0...

big bang - designing a statically typed scripting...