-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathpublications.html
More file actions
288 lines (222 loc) · 26.8 KB
/
publications.html
File metadata and controls
288 lines (222 loc) · 26.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="description" content="JPC Publications" />
<meta name="keywords" content="JPC, multi-paradigm programming, logic-programming, object-oriented programming" />
<meta name="author" content="Sergio Castro" />
<title>JPC Publications</title>
<link rel="stylesheet" href="styles/publication/sc.tutorial.css" />
<link rel="stylesheet" href="styles/publication/sc.tooglejs.css" />
<link rel="stylesheet" href="styles/publication/sc.publication.css" />
<link rel="stylesheet" href="styles/htmlExportStyleSheet.css" />
<link rel="stylesheet" href="styles/themes/base/jquery.ui.all.css" />
<script type="text/javascript" src="js/jquery.min.js"></script>
<script type="text/javascript" src="js/jquery-ui.custom.min.js"></script>
<script type="text/javascript" src="js/publication/jquery.sc.blog.js"></script>
<script type="text/javascript" src="js/publication/ZeroClipboard.js"></script>
<script type="text/javascript" src="js/publication/jquery.sc.copyDialog.js"></script>
<script type="text/javascript" src="js/publication/BibTex.min.js"></script>
<script type="text/javascript" src="js/publication/jquery.sc.bibtex.js"></script>
<script type="text/javascript">//<![CDATA[
(function ($) {
$(function() {
$('body').attr('id','JS');
$('.JSOnlyContent').show();
var publicationsDistribution = [
{publicationType: null, target: 'processedPublicationsContent'}
];
/*
var publicationsDistribution = [
{publicationType: 'article', target: 'processedPublicationsContent'},
{publicationType: 'conference', target: 'processedPublicationsContent'},
{publicationType: 'inproceedings', target: 'processedPublicationsContent'},
{publicationType: 'unpublished', target: 'processedPublicationsContent'},
{publicationType: 'techreport', target: 'processedPublicationsContent'},
{publicationType: 'misc', target: 'processedPublicationsContent'},
{publicationType: 'mastersthesis', target: 'processedPublicationsContent'}
];
*/
$.classifyPublications('allPublications', publicationsDistribution);
});
})(jQuery);
//]]></script>
</head>
<body id="noJS">
<h1 id="publications_header" class="siteMapAnchor">JPC Related Publications</h1>
<div class="contentView">
<div class="JSOnlyContent" >
<div id="processedPublicationsContent" class="publicationsContent" ></div>
</div>
<div id="allPublications" class="noJSContent"> <!-- bibtex container div-->
<!-- BEGIN OF BIBTEX GENERATED PUBLICATIONS -->
<div class="publicationsContent">
<dl>
<dt class="Title">Automatic Integration of Hybrid Java-Prolog Entities with LogicObjects</dt>
<dd class="Pub">
<span class="Author">S. Castro and K. Mens and P. Moura</span>.
<span class="Journal">Association for Logic Programming (ALP) Newsletter. Out of Left Field track. December Issue</span>. (<span>December, 2014</span>). <span class="BibTex">@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}}</span>
</dd>
<dt class="Title">A Portable Approach for Bidirectional Integration between a Logic and a Statically-Typed Object-Oriented Programming Language</dt>
<dd class="Pub">
<span class="Author">S. Castro</span>.
<span class="School">Université catholique de Louvain (Belgium)</span>. <span class="Other">Phd thesis</span>. (<span>September, 2014</span>). <span class="BibTex">@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==}}</span>
</dd>
<dt class="Title">Customisable Handling of Java References in Prolog Programs</dt>
<dd class="Pub">
<span class="Author">S. Castro and K. Mens and P. Moura</span>.
<span class="Booktitle">Proceedings of the 30th International Conference on Logic Programming (ICLP)</span>. (<span>July, 2014</span>). <span class="BibTex">@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==}}</span>
</dd>
<dt class="Title">JPC: A Library for Categorising and Applying Inter-Language Conversions Between Java and Prolog</dt>
<dd class="Pub">
<span class="Author">S. Castro and K. Mens and P. Moura</span>.
<span class="Journal">Science of Computer Programming: Experimental Software and Toolkits (EST 6) (Under Evaluation)</span>. (<span>2014</span>). <span class="BibTex">@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=}}</span>
</dd>
<dt class="Title">LogicObjects: A Portable and Extensible Approach for Linguistic Symbiosis between an Object-Oriented and a Logic Programming Language</dt>
<dd class="Pub">
<span class="Author">S. Castro</span>.
<span class="Booktitle">Proceedings of the International Conference on Logic Programming, Doctoral Consortium (ICLP DC)</span>. (<span>August, 2013</span>). <span class="BibTex">@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}}</span>
</dd>
<dt class="Title">LogicObjects: Enabling Logic Programming in Java through Linguistic Symbiosis</dt>
<dd class="Pub">
<span class="Author">S. Castro and K. Mens and P. Moura</span>.
<span class="Booktitle">Proceedings of the 15th International Symposium on Practical Aspects of Declarative Languages (PADL)</span>. Editor: <span class="Editor">Sagonas, Kostis</span>. V. <span class="Volume">7752</span> P. <span class="VolumePages">26-42</span> <span class="Address">Rome, Italy</span> (<span>January, 2013</span>). <span class="BibTex">@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==}}</span>
</dd>
<dt class="Title">LogicObjects: A Linguistic Symbiosis Approach to Bring the Declarative Power of Prolog to Java</dt>
<dd class="Pub">
<span class="Author">S. Castro and K. Mens and P. Moura</span>.
<span class="Booktitle">Proceedings of the 9th ECOOP Workshop on Reflection, AOP, and Meta-Data for Software Evolution</span>. P. <span class="VolumePages">11--16</span> (<span>June, 2012</span>). <span class="BibTex">@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=}}</span>
</dd>
</dl>
</div>
<!-- END OF BIBTEX GENERATED PUBLICATIONS -->
</div> <!-- end of bibtex container div-->
And more coming soon.
<div class="clearfloat"></div>
</div>
</body>
</html>