- Automatic Integration of Hybrid Java-Prolog Entities with LogicObjects
-
S. Castro and K. Mens and P. Moura.
Association for Logic Programming (ALP) Newsletter. Out of Left Field track. December Issue. (December, 2014). @article{2014-alp-castro,
Abstract = {Logic languages excel for problems that can defined declaratively, e.g. applications that require symbolic computation such as expert and planning systems. However, it is often difficult to develop complete applications that require e.g. GUIs, heavy numerical computations, or low-level operating system and network access. On the other hand, object-oriented languages have demonstrated their usefulness for modelling a wide range of concepts (e.g., GUIs) found in many business scenarios. The availability of continuously growing software ecosystems around widely used modern object-oriented languages, including advanced IDEs and rich sets of libraries, has significantly contributed to their success.
Non-trivial applications can profit from implementing their components, or even distinct routines of the same entity, in the language that is most appropriate for expressing them. However, the integration of programs or routines written in different languages is not trivial when such languages belong to different paradigms.
Although numerous approaches allow to integrate Java and Prolog programs, few of them put an emphasis on the transparency and automation of the integration concern at the entity level. In this article, we describe an approach based on the notion of automatic inter-language conversions that does tackle this problem.
},
Annote = {CastroPublication
JPCPublication},
Author = {Sergio Castro and Kim Mens and Paulo Moura},
Date-Added = {2014-08-26 11:44:48 +0000},
Date-Modified = {2014-08-31 19:23:23 +0000},
Journal = {{Association for Logic Programming (ALP) Newsletter. Out of Left Field track. December Issue}},
Month = {December},
Title = {{Automatic Integration of Hybrid Java-Prolog Entities with LogicObjects}},
Url = {http://java-prolog-connectivity.github.com/short_paper.html},
Year = {2014},
Bdsk-Url-1 = {http://java-prolog-connectivity.github.com/short_paper.html}}
- A Portable Approach for Bidirectional Integration between a Logic and a Statically-Typed Object-Oriented Programming Language
-
S. Castro.
Université catholique de Louvain (Belgium). Phd thesis. (September, 2014). @phdthesis{2014-phd-castro,
Abstract = {This dissertation seeks to improve on the state of the art for creating systems integrating modules written in both a logic and a statically-typed object-oriented language. Logic languages are well suited for declaratively solving computational problems that require knowledge representation and reasoning. Modern object-oriented programming languages benefit from mature software ecosystems featuring rich libraries and developer tools. The existence of several integration approaches testifies the interest of both communities in techniques for facilitating the creation of hybrid systems. In this way, systems developed in an object-oriented language can integrate modules written in a logic language that are more convenient for solving declarative problems. On the logic side, non-trivial declarative applications can take advantage of the existence of large software ecosystems such as those surrounding contemporary object-oriented languages. The combination of both paradigms allows a programmer to use the best language available for a given task.
Existing integration approaches provide different levels of abstractions for dealing with the integration concern (i.e., the required interoperability in order for logic routines to access the object-oriented world, and vice versa). Some of them still require significant amounts of boilerplate code which hinders their adoption and steepens their learning curve. Others provide a high degree of integration transparency and automation which simplifies their usage. However, many of those approaches often impose strong assumptions about the architecture of a system (e.g., a logic program must run embedded in an object-oriented one) thus suffering from portability issues. Furthermore, most approaches provide limited support for custom context-dependent reification of objects in the logic world and custom mappings of arbitrary logic terms to objects in the object-oriented world.
To address these problems, we introduce our portable and customisable approach for bidirectional integration between a logic and a statically-typed object-oriented language. This approach enables a transparent and (semi-) automatic communication between routines in these two worlds. In addition, it provides a customisable context-dependent mechanism for defining how artefacts in one language should be reified in the other language. A concrete implementation is provided as a portable Java--Prolog interoperability framework.
To ensure portability, our framework has been made compatible with three open source Prolog engines (SWI, YAP and XSB) by means of drivers.
We validated our approach through case studies requiring a seamless integration of declarative programs in Prolog with object-oriented programs in Java.
},
Annote = {CastroPublication
JPCPublication
},
Author = {Sergio Castro},
Date-Added = {2014-08-20 11:17:07 +0000},
Date-Modified = {2014-08-31 19:05:01 +0000},
Keywords = {Logic Programming, Object-Oriented Programming, Multi-Paradigm Programming, Language Interoperability, Java, Prolog},
Month = {September},
School = {{Universit{\'e} catholique de Louvain (Belgium)}},
Title = {A Portable Approach for Bidirectional Integration between a Logic and a Statically-Typed Object-Oriented Programming Language},
Type = {Phd thesis},
Year = {2014},
Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QEzIwMTQtcGhkLWNhc3Ryby5wZGbSFwsYGVdOUy5kYXRhTxEBvAAAAAABvAACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAzeTDuUgrAAAACte5EzIwMTQtcGhkLWNhc3Ryby5wZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGpuhDQJCvSAAAAAAAAAAAAAQACAAAJIAAAAAAAAAAAAAAAAAAAAAZwYXBlcnMAEAAIAADN5KeZAAAAEQAIAADQJA+yAAAAAQAUAArXuQAKvsgACiNDAAoNdwAKDWsAAgBNTWFjaW50b3NoIEhEOlVzZXJzOgBzZXJnaW9jOgBEb2N1bWVudHM6AHJlc2VhcmNoOgBwYXBlcnM6ADIwMTQtcGhkLWNhc3Ryby5wZGYAAA4AKAATADIAMAAxADQALQBwAGgAZAAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgA7VXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMTQtcGhkLWNhc3Ryby5wZGYAABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4ApACpALECcQJzAngCgwKMApoCngKlAq4CswLAAsMC1QLYAt0AAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAAC3w==}}
- Customisable Handling of Java References in Prolog Programs
-
S. Castro and K. Mens and P. Moura.
Proceedings of the 30th International Conference on Logic Programming (ICLP). (July, 2014). @conference{2014-iclp-castro,
Abstract = {Integration techniques for combining programs written in distinct language paradigms facilitate the implementation of specialised modules in the best language for their task. In the case of Java-Prolog integration, a known problem is the proper representation of references to Java objects on the Prolog side. To solve it adequately, multiple dimensions should be considered, including reference representation, opacity of the representation, identity preservation, reference life span, and scope of the inter-language conversion policies. This paper presents an approach that addresses all these dimensions, generalising and building on existing representation patterns of foreign references in Prolog, and taking inspiration from similar inter-language representation techniques found in other domains. Our approach maximises portability by making few assumptions about the Prolog engine interacting with Java (e.g., embedded or executed as an external process). We validate our work by extending JPC, an open-source integration library, with features supporting our approach. Our JPC library is currently compatible with three different open source Prolog engines (SWI, YAP and XSB) by means of drivers.},
Annote = {CastroPublication
JPCPublication
},
Author = {Castro, Sergio and Mens, Kim and Moura, Paulo},
Booktitle = {Proceedings of the 30th International Conference on Logic Programming (ICLP)},
Date-Added = {2014-04-18 18:29:25 +0000},
Date-Modified = {2014-08-31 19:03:02 +0000},
Keywords = {Logic Programming, Object-Oriented Programming, Multi-Paradigm Programming, Language Interoperability, Java, Prolog},
Month = {July},
Title = {Customisable Handling of Java References in Prolog Programs},
Year = {2014},
Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFDIwMTQtaWNscC1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAb4AAAAAAb4AAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuRQyMDE0LWljbHAtY2FzdHJvLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAt+FczyKPeQAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAzyKBaQAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIATk1hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDE0LWljbHAtY2FzdHJvLnBkZgAOACoAFAAyADAAMQA0AC0AaQBjAGwAcAAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgA8VXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMTQtaWNscC1jYXN0cm8ucGRmABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4ApQCqALICdAJ2AnsChgKPAp0CoQKoArECtgLDAsYC2ALbAuAAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAAC4g==}}
- JPC: A Library for Categorising and Applying Inter-Language Conversions Between Java and Prolog
-
S. Castro and K. Mens and P. Moura.
Science of Computer Programming: Experimental Software and Toolkits (EST 6) (Under Evaluation). (2014). @article{2014-scico-castro,
Abstract = {The number of approaches existing to enable a smooth interaction between Java and Prolog programs testifies the growing interest in solutions that combine the strengths of both languages. Most of these approaches provide limited support to allow programmers to customise how Prolog artefacts should be reified in the Java world, or how to reason about Java objects on the Prolog side. This is an error-prone task since often a considerable amount of mappings must be developed and organised. Furthermore, appropriate mappings may depend on the particular context in which a conversion is accomplished. Although some libraries alleviate this problem by providing higher-level abstractions to deal with the complexity of custom conversions between artefacts of the two languages, these libraries themselves are difficult to implement and evolve. We claim that this is caused by their lack of appropriate underlying building blocks for encapsulating, categorising and applying Java-Prolog conversion routines. We therefore introduce a new library, JPC, serving as a development tool for both programmers willing to categorise context-dependent conversion constructs in their Java-Prolog systems, and for architects implementing frameworks providing higher-level abstractions for better interoperability between these two languages.},
Annote = {CastroPublication
JPCPublication},
Author = {Sergio Castro and Kim Mens and Paulo Moura},
Date-Added = {2014-04-18 19:17:38 +0000},
Date-Modified = {2014-08-31 19:23:36 +0000},
Journal = {Science of Computer Programming: Experimental Software and Toolkits (EST 6) (Under Evaluation)},
Keywords = {Object-Oriented Programming, Logic Programming, Multi-Paradigm Programming, Programming Language Interoperability, Separation of Concerns},
Title = {JPC: A Library for Categorising and Applying Inter-Language Conversions Between Java and Prolog},
Year = {2014},
Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFTIwMTQtc2NpY28tY2FzdHJvLnBkZtIXCxgZV05TLmRhdGFPEQHEAAAAAAHEAAIAAAxNYWNpbnRvc2ggSEQAAAAAAAAAAAAAAAAAAADN5MO5SCsAAAAK17kVMjAxNC1zY2ljby1jYXN0cm8ucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAR5BJ89F8KcAAAAAAAAAAAABAAIAAAkgAAAAAAAAAAAAAAAAAAAABnBhcGVycwAQAAgAAM3kp5kAAAARAAgAAM9F4pcAAAABABQACte5AAq+yAAKI0MACg13AAoNawACAE9NYWNpbnRvc2ggSEQ6VXNlcnM6AHNlcmdpb2M6AERvY3VtZW50czoAcmVzZWFyY2g6AHBhcGVyczoAMjAxNC1zY2ljby1jYXN0cm8ucGRmAAAOACwAFQAyADAAMQA0AC0AcwBjAGkAYwBvAC0AYwBhAHMAdAByAG8ALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAD1Vc2Vycy9zZXJnaW9jL0RvY3VtZW50cy9yZXNlYXJjaC9wYXBlcnMvMjAxNC1zY2ljby1jYXN0cm8ucGRmAAATAAEvAAAVAAIADv//AACABtIbHB0eWiRjbGFzc25hbWVYJGNsYXNzZXNdTlNNdXRhYmxlRGF0YaMdHyBWTlNEYXRhWE5TT2JqZWN00hscIiNcTlNEaWN0aW9uYXJ5oiIgXxAPTlNLZXllZEFyY2hpdmVy0SYnVHJvb3SAAQAIABEAGgAjAC0AMgA3AEAARgBNAFUAYABnAGoAbABuAHEAcwB1AHcAhACOAKYAqwCzAnsCfQKCAo0ClgKkAqgCrwK4Ar0CygLNAt8C4gLnAAAAAAAAAgEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAuk=}}
- LogicObjects: A Portable and Extensible Approach for Linguistic Symbiosis between an Object-Oriented and a Logic Programming Language
-
S. Castro.
Proceedings of the International Conference on Logic Programming, Doctoral Consortium (ICLP DC). (August, 2013). @inproceedings{2013-iclp-castro,
Abstract = {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.},
Annote = {CastroPublication
JPCPublication},
Author = {Castro, Sergio},
Booktitle = {Proceedings of the International Conference on Logic Programming, Doctoral Consortium (ICLP DC)},
Date-Added = {2013-08-09 13:21:35 +0000},
Date-Modified = {2014-08-31 19:03:16 +0000},
Keywords = {Logic Programming, Object-Oriented Programming, Multi-Paradigm Programming, Linguistic Integration},
Month = {August},
Title = {LogicObjects: A Portable and Extensible Approach for Linguistic Symbiosis between an Object-Oriented and a Logic Programming Language},
Year = {2013},
Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QInNlcmdpbyBjYXN0cm8vMjAxMy1pY2xwLWNhc3Ryby5wZGbSFwsYGVdOUy5kYXRhTxEB6AAAAAAB6AACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAzeTDuUgrAAAACthPFDIwMTMtaWNscC1jYXN0cm8ucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACk2OvPDWxLAAAAAAAAAAAAAQADAAAJIAAAAAAAAAAAAAAAAAAAAA1zZXJnaW8gY2FzdHJvAAAQAAgAAM3kp5kAAAARAAgAAM8NXjsAAAABABgACthPAArXuQAKvsgACiNDAAoNdwAKDWsAAgBdTWFjaW50b3NoIEhEOlVzZXJzOgBzZXJnaW9jOgBEb2N1bWVudHM6AHJlc2VhcmNoOgBwYXBlcnM6AHNlcmdpbyBjYXN0cm86ADIwMTMtaWNscC1jYXN0cm8ucGRmAAAOACoAFAAyADAAMQAzAC0AaQBjAGwAcAAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgBKVXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzL3NlcmdpbyBjYXN0cm8vMjAxMy1pY2xwLWNhc3Ryby5wZGYAEwABLwAAFQACAA7//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgCzALgAwAKsAq4CswK+AscC1QLZAuAC6QLuAvsC/gMQAxMDGAAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAAMa}}
- LogicObjects: Enabling Logic Programming in Java through Linguistic Symbiosis
-
S. Castro and K. Mens and P. Moura.
Proceedings of the 15th International Symposium on Practical Aspects of Declarative Languages (PADL). Editor: Sagonas, Kostis. V. 7752 P. 26-42 Rome, Italy (January, 2013). @conference{2013-padl-castro,
Abstract = {While object-oriented programming languages are good at
modelling real-world concepts and benefit from rich libraries and developer
tools, logic programming languages are well suited for declaratively
solving computational problems that require knowledge reasoning. Non-trivial
declarative applications could take advantage of the modelling features
of object-oriented programming and of the rich software ecosystems
surrounding them. Linguistic symbiosis is a common approach to enable
complementary use of languages of different paradigms. However, the
problem of concepts leaking from one paradigm to another often hinders
the applicability of such approaches. This issue has mainly been reported
for object-oriented languages participating in a symbiotic relation with
a logic language. To address this issue, we present LogicObjects, a linguistic
symbiosis framework for transparently and (semi-) automatically
enabling logic programming in Java, that aims to solve most of the problems
of paradigm leaking reported in other works.},
Address = {Rome, Italy},
Annote = {CastroPublication
JPCPublication},
Author = {Castro, Sergio and Mens, Kim and Moura, Paulo},
Booktitle = {Proceedings of the 15th International Symposium on Practical Aspects of Declarative Languages (PADL)},
Date-Added = {2014-01-19 16:23:32 +0000},
Date-Modified = {2014-08-31 19:03:06 +0000},
Editor = {Sagonas, Kostis},
Keywords = {Linguistic Symbiosis, Object-Oriented Programming, Logic Programming, Multi-paradigm programming},
Month = {January},
Pages = {26-42},
Publisher = {Springer Berlin Heidelberg},
Series = {Lecture Notes in Computer Science},
Title = {{LogicObjects: Enabling Logic Programming in Java through Linguistic Symbiosis}},
Volume = {7752},
Year = 2013,
Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFDIwMTMtcGFkbC1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAb4AAAAAAb4AAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuRQyMDEzLXBhZGwtY2FzdHJvLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtfUzNUlPAAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAzNUXLAAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIATk1hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDEzLXBhZGwtY2FzdHJvLnBkZgAOACoAFAAyADAAMQAzAC0AcABhAGQAbAAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgA8VXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMTMtcGFkbC1jYXN0cm8ucGRmABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4ApQCqALICdAJ2AnsChgKPAp0CoQKoArECtgLDAsYC2ALbAuAAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAAC4g==}}
- LogicObjects: A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java
-
S. Castro and K. Mens and P. Moura.
Proceedings of the 9th ECOOP Workshop on Reflection, AOP, and Meta-Data for Software Evolution. P. 11--16 (June, 2012). @inproceedings{2012-ramse-castro,
Abstract = {Logic programming is well suited for declaratively solving computational problems that require knowledge representation and reasoning. Object-oriented languages, on the other hand, are well suited for modeling real-world concepts and profit from rich ecosystems developed around them, which are often missing from logic languages. For applications that require both the declarative power of logic programming and the rich modeling expressiveness and development environments offered by object-oriented languages, there is a need for reconciling both worlds. LogicObjects is our linguistic symbiosis framework for integrating Prolog within the Java language. It extends Java with annotations that allow Java programs to interact transparently and automatically with Prolog programs.},
Annote = {CastroPublication
JPCPublication},
Author = {Castro, Sergio and Mens, Kim and Moura, Paulo},
Booktitle = {Proceedings of the 9th ECOOP Workshop on Reflection, AOP, and Meta-Data for Software Evolution},
Date-Added = {2012-05-30 07:55:37 +0000},
Date-Modified = {2014-08-31 19:03:25 +0000},
Keywords = {Linguistic Symbiosis, Object-Oriented Programming, Logic Programming, Multi-paradigm programming},
Month = {June},
Pages = {11--16},
Publisher = {ACM},
Series = {RAM-SE'12},
Title = {LogicObjects: A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java},
Year = {2012},
Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFTIwMTItcmFtc2UtY2FzdHJvLnBkZtIXCxgZV05TLmRhdGFPEQHEAAAAAAHEAAIAAAxNYWNpbnRvc2ggSEQAAAAAAAAAAAAAAAAAAADN5MO5SCsAAAAK17kVMjAxMi1yYW1zZS1jYXN0cm8ucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArX08vWqAYAAAAAAAAAAAABAAIAAAkgAAAAAAAAAAAAAAAAAAAABnBhcGVycwAQAAgAAM3kp5kAAAARAAgAAMvWi+YAAAABABQACte5AAq+yAAKI0MACg13AAoNawACAE9NYWNpbnRvc2ggSEQ6VXNlcnM6AHNlcmdpb2M6AERvY3VtZW50czoAcmVzZWFyY2g6AHBhcGVyczoAMjAxMi1yYW1zZS1jYXN0cm8ucGRmAAAOACwAFQAyADAAMQAyAC0AcgBhAG0AcwBlAC0AYwBhAHMAdAByAG8ALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAD1Vc2Vycy9zZXJnaW9jL0RvY3VtZW50cy9yZXNlYXJjaC9wYXBlcnMvMjAxMi1yYW1zZS1jYXN0cm8ucGRmAAATAAEvAAAVAAIADv//AACABtIbHB0eWiRjbGFzc25hbWVYJGNsYXNzZXNdTlNNdXRhYmxlRGF0YaMdHyBWTlNEYXRhWE5TT2JqZWN00hscIiNcTlNEaWN0aW9uYXJ5oiIgXxAPTlNLZXllZEFyY2hpdmVy0SYnVHJvb3SAAQAIABEAGgAjAC0AMgA3AEAARgBNAFUAYABnAGoAbABuAHEAcwB1AHcAhACOAKYAqwCzAnsCfQKCAo0ClgKkAqgCrwK4Ar0CygLNAt8C4gLnAAAAAAAAAgEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAuk=}}
And more coming soon.