leftBackground
rightBackground
 
 

Home

Contact Details

Sergio Castro
Software Engineer and Researcher
E-mail: sergioc78(at)gmail(dot)com
LinkedIn icon SSH icon PGP icon
Sergio Castro

Short bio

Sergio Castro is an expert software engineer and researcher currently affiliated with TomTom.
He holds a PhD in Engineering Sciences (specialization: Computer Science) from the Université catholique de Louvain (UCL), Belgium, an International Master in Computer Science from the Vrije Universiteit Brussel (VUB), Belgium and the Ecole des Mines de Nantes (EMN), France (double diploma program), and a degree in Computer Engineering specialized in Information Systems from the Escuela Superior Politécnica del Litoral (ESPOL), Ecuador.
One of his main professional interests is related to the research and application of mechanisms for the automatic integration of hybrid object-oriented and logic programs. Other interests involve logic programming techniques for mining, measuring, refactoring and transforming object-oriented programs and other software artefacts.
Sergio is also an occasional contributor to the Logtalk project.

A detailed CV can be downloaded here.

Research

Current Research

I am researching portable techniques for the automatic integration of hybrid object-oriented and logic programs. My experimentation languages are currently Java and Prolog.

I am also interested in logic programming approaches for mining, measuring, refactoring and transforming distinct kinds of software artefacts (e.g., source code of object-oriented programs).

You can check out my projects in the public domain, on this and other topics, at GitHub.

Research Artefacts

A set of software artefacts was developed to validate and experiment with different aspects of my research. The most relevant artefacts are:

  • Java–Prolog Connectivity (JPC): JPC is a Java-Prolog interoperability library providing different levels of integration abstractions. One of the core JPC components consists of a module in charge of inter-language conversions between Java and Prolog artefacts. In many aspects, this module is a re-implementation of Google’s Gson, a state of the art library for accomplishing conversions between Java and Json artefacts. JPC is currently compatible with three open-source Prolog engines: SWI, YAP and XSB Prolog.
  • LogicObjects: LogicObjects extends JPC by means of integrating Java and Prolog programs at the linguistic level. In this way, routines between the two worlds can be invoked transparently and foreign language artefacts can be referenced as local ones.
  • JConverter: JConverter generalises on the inter-language conversion techniques originally defined in JPC. It defines an architectural pattern for accomplishing type-guided conversions between arbitrary artefacts in Java.
  • JCategory: JCategory allows to create and manipulate different kinds of categorisations in Java. Named and typed categorisations are at the core of other libraries implemented in the context of my research.

Previous Work

Other previous (unmaintained) open source projects I have been involved in are:

  • Heal: A SOUL library for diagnosing and correcting design inconsistencies in Smalltalk by means of logic abductive reasoning and inter-language reflection.
  • JAsCo: Implementation of the distributed cflow construct.

Publications

Journals

Conferences

Workshops

Published

Unpublished

Seminars

Technical Reports

Theses

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. }, Author = {Sergio Castro}, Date-Added = {2014-08-20 11:17:07 +0000}, Date-Modified = {2014-08-25 15:56:04 +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 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QEzIwMTQtcGhkLWNhc3Ryby5wZGbSFwsYGVdOUy5kYXRhTxEBvAAAAAABvAACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAzeTDuUgrAAAACte5EzIwMTQtcGhkLWNhc3Ryby5wZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGlGqbQIPUTAAAAAAAAAAAAAQACAAAJIAAAAAAAAAAAAAAAAAAAAAZwYXBlcnMAEAAIAADN5KeZAAAAEQAIAADQINjzAAAAAQAUAArXuQAKvsgACiNDAAoNdwAKDWsAAgBNTWFjaW50b3NoIEhEOlVzZXJzOgBzZXJnaW9jOgBEb2N1bWVudHM6AHJlc2VhcmNoOgBwYXBlcnM6ADIwMTQtcGhkLWNhc3Ryby5wZGYAAA4AKAATADIAMAAxADQALQBwAGgAZAAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgA7VXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMTQtcGhkLWNhc3Ryby5wZGYAABMAAS8AABUAAgAO//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 = {Castro_publication JPC_publication }, 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-20 11:16:05 +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) (Submitted). (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 = {Castro_publication JPC_publication}, Author = {Sergio Castro and Kim Mens and Paulo Moura}, Date-Added = {2014-04-18 19:17:38 +0000}, Date-Modified = {2014-05-06 14:23:41 +0000}, Journal = {Science of Computer Programming: Experimental Software and Toolkits (EST 6) (Submitted)}, 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=}}
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. (2014).  @article{2014-alp-castro, Abstract = {Logic languages excel for problems that can be 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. }, Author = {Sergio Castro and Kim Mens and Paulo Moura}, Date-Added = {2014-08-26 11:44:48 +0000}, Date-Modified = {2014-08-26 11:53:23 +0000}, Journal = {Association for Logic Programming (ALP) Newsletter. Out of Left Field track. December Issue}, Title = {Automatic Integration of Hybrid Java-Prolog Entities with LogicObjects}, Url = {http://java-prolog-connectivity.github.com/short_paper.html}, Year = {2014}}
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 = {Castro_publication JPC_publication}, 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-04-19 23:17:42 +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}}
Hydra: An Extensible Multi-Engine Prolog Query Browser
S. Castro and P. Moura and K. Mens. Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Bern, Switzerland. (July, 2013).  @misc{2013-sattose-castro-2, Annote = {Castro_publication}, Author = {Castro, Sergio and Moura, Paulo and Mens, Kim}, Date-Added = {2013-08-09 13:38:17 +0000}, Date-Modified = {2014-04-19 23:17:48 +0000}, Howpublished = {Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Bern, Switzerland}, Keywords = {Logic Programming, Multi-Paradigm Programming, Programming Language Interoperability, Software Ecosystems, Reusable Components}, Month = {July}, Title = {Hydra: An Extensible Multi-Engine Prolog Query Browser}, Year = {2013}}
Towards a Software Ecosystem for Java-Prolog Interoperability
S. Castro and K. Mens and P. Moura. Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Bern, Switzerland. (July, 2013).  @misc{2013-sattose-castro-1, Annote = {Castro_publication}, Author = {Castro, Sergio and Mens, Kim and Moura, Paulo}, Date-Added = {2013-08-09 13:38:04 +0000}, Date-Modified = {2014-04-19 23:18:00 +0000}, Howpublished = {Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Bern, Switzerland}, Keywords = {Software Ecosystems, Object--Oriented Programming, Logic Programming, Multi--Paradigm Programming}, Month = {July}, Title = {Towards a Software Ecosystem for Java-Prolog Interoperability}, Year = {2013}}
JPC: A Library for Modularising Inter-Language Conversion Concerns between Java and Prolog
S. Castro and K. Mens and P. Moura. International Workshop on Advanced Software Development Tools and Techniques (WASDeTT). Co-located with the European Conference in Object-Oriented Programming (ECOOP). (July, 2013).  @unpublished{2013-wasdett-castro, Annote = {Castro_publication}, Author = {Castro, Sergio and Mens, Kim and Moura, Paulo}, Booktitle = {International Workshop on Advanced Software Development Tools and Techniques (WASDeTT). Co-located with the European Conference in Object-Oriented Programming (ECOOP)}, Date-Added = {2013-08-09 13:31:53 +0000}, Date-Modified = {2014-04-19 23:17:55 +0000}, Keywords = {Object-Oriented Programming, Logic Programming, Multi-Paradigm Programming, Programming Language Interoperability, Separation of Concerns}, Month = {July}, Title = {JPC: A Library for Modularising Inter-Language Conversion Concerns between Java and Prolog}, Year = {2013}}
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 = {Castro_publication JPC_publication}, 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-05-31 23:29:20 +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 = {Castro_publication JPC_publication}, 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-05-18 11:33:23 +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=}}
DynamicSchema: A Lightweight Persistency Framework for Context-Oriented Data Management
S. Castro and S. González and K. Mens and M. Denker. Proceedings of the Workshop on Context-Oriented Programming (COP'12). (June, 2012).  @inproceedings{2012-cop-castro, Abstract = {While context-oriented programming technology so far has focused mostly on behavioral adaptation, context-oriented data management has received much less attention. In this paper we make a case for the problem of context-oriented data management, using a concrete example of a mobile application. We illustrate some of the issues involved and propose a lightweight persistency framework, called DynamicSchema, that resolves some of these issues. The solution consists in a flexible reification of the database schema, as a convenient dynamic data structure that can be adapted at execution time, according to sensed context changes. Implementing our mobile application using this framework enabled us to reduce the complexity of the domain modeling layer, to facilitate the production of code with low memory footprint, and to simplify the implementation of certain scenarios related to context-dependent security concerns.}, Annote = {Castro_publication}, Author = {Castro, Sergio and {Gonz{\'a}lez}, {Sebasti{\'a}n} and Mens, Kim and Denker, Marcus}, Booktitle = {Proceedings of the Workshop on Context-Oriented Programming (COP'12)}, Date-Added = {2012-07-09 13:32:31 +0000}, Date-Modified = {2014-04-19 23:18:11 +0000}, Keywords = {Context-Oriented Data Management, Data Access Layer, Dynamic Adaptability, Persistency}, Month = {June}, Title = {DynamicSchema: A Lightweight Persistency Framework for Context-Oriented Data Management}, Year = {2012}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QEzIwMTItY29wLWNhc3Ryby5wZGbSFwsYGVdOUy5kYXRhTxEBvAAAAAABvAACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAzeTDuUgrAAAACte5EzIwMTItY29wLWNhc3Ryby5wZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK19LLn3qsAAAAAAAAAAAAAQACAAAJIAAAAAAAAAAAAAAAAAAAAAZwYXBlcnMAEAAIAADN5KeZAAAAEQAIAADLn16MAAAAAQAUAArXuQAKvsgACiNDAAoNdwAKDWsAAgBNTWFjaW50b3NoIEhEOlVzZXJzOgBzZXJnaW9jOgBEb2N1bWVudHM6AHJlc2VhcmNoOgBwYXBlcnM6ADIwMTItY29wLWNhc3Ryby5wZGYAAA4AKAATADIAMAAxADIALQBjAG8AcAAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgA7VXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMTItY29wLWNhc3Ryby5wZGYAABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4ApACpALECcQJzAngCgwKMApoCngKlAq4CswLAAsMC1QLYAt0AAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAAC3w==}}
Generation of corrective actions to code design problems
S. Castro. Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Koblenz, Germany. (April, 2011).  @misc{2011-sattose-castro, Annote = {Castro_publication}, Author = {S. Castro}, Date-Added = {2011-04-08 14:45:58 +0200}, Date-Modified = {2014-04-19 23:18:23 +0000}, Howpublished = {Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Koblenz, Germany}, Keywords = {inconsistency management}, Month = {April}, Title = {Generation of corrective actions to code design problems}, Year = {2011}}
Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction
S. Castro and C. D. Roover and A. Kellens and A. Lozano and K. Mens and T. D'Hondt. Science of Computer Programming: Special Issue on Software Evolution, Adaptability and Variability. V. 76 N. 12 P. 1113-1129 (December, 2010).  @article{2010-scico-castro, Abstract = {Correcting design decay in source code is not a trivial task. Diagnosing and subsequently correcting inconsistencies between a software systems's code and its design rules (e.g., database queries are only allowed in the persistence layer) and coding conventions can be complex, time-consuming and error-prone. Providing support for this process is therefore highly desirable, but of a far greater complexity than suggesting basic corrective actions for simplistic implementation problems (like the ``declare a local variable for non-declared variable'' suggested by Eclipse). We present an abductive reasoning approach to inconsistency correction that consists of (1) a means for developers to document and verify a system's design and coding rules, (2) an abductive logic reasoner that hypothesizes possible causes of inconsistencies between the system's code and the documented rules and (3) a library of corrective actions for each hypothesized cause. This work builds on our previous work, where we expressed design rules as equality relationships between sets of source code artifacts (e.g., the set of methods in the persistence layer is the same as the set of methods that query the database). In this paper, we generalize our approach to design rules expressed as user-defined binary relationships between two sets of source code artifacts (e.g., every state changing method should invoke a persistence method). We illustrate our approach on the design of IntensiVE, a tool suite that enables defining sets of source code artifacts intensionally (by means of logic queries) and verifying relationships between such sets.}, Annote = {Castro_publication}, Author = {Sergio Castro and Coen De Roover and Andy Kellens and Angela Lozano and Kim Mens and Theo D'Hondt}, Date-Added = {2010-11-10 16:45:07 +0100}, Date-Modified = {2014-04-19 23:18:28 +0000}, Doi = {DOI: 10.1016/j.scico.2010.09.001}, Issn = {0167-6423}, Journal = {Science of Computer Programming: Special Issue on Software Evolution, Adaptability and Variability}, Keywords = {inconsistency management, abductive reasoning, logic meta programming}, Month = {December}, Number = {12}, Pages = {1113-1129}, Title = {Diagnosing and Correcting Design Inconsistencies in Source Code with Logical Abduction}, Url = {http://www.sciencedirect.com/science/article/B6V17-511TN7T-1/2/ea5faf2030ad3a65e517e9b8a0c6a2bf}, Volume = {76}, Year = {2010}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFTIwMTAtc2NpY28tY2FzdHJvLnBkZtIXCxgZV05TLmRhdGFPEQHEAAAAAAHEAAIAAAxNYWNpbnRvc2ggSEQAAAAAAAAAAAAAAAAAAADN5MO5SCsAAAAK17kVMjAxMC1zY2ljby1jYXN0cm8ucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArX0cjFFagAAAAAAAAAAAABAAIAAAkgAAAAAAAAAAAAAAAAAAAABnBhcGVycwAQAAgAAM3kp5kAAAARAAgAAMjE+YgAAAABABQACte5AAq+yAAKI0MACg13AAoNawACAE9NYWNpbnRvc2ggSEQ6VXNlcnM6AHNlcmdpb2M6AERvY3VtZW50czoAcmVzZWFyY2g6AHBhcGVyczoAMjAxMC1zY2ljby1jYXN0cm8ucGRmAAAOACwAFQAyADAAMQAwAC0AcwBjAGkAYwBvAC0AYwBhAHMAdAByAG8ALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAD1Vc2Vycy9zZXJnaW9jL0RvY3VtZW50cy9yZXNlYXJjaC9wYXBlcnMvMjAxMC1zY2ljby1jYXN0cm8ucGRmAAATAAEvAAAVAAIADv//AACABtIbHB0eWiRjbGFzc25hbWVYJGNsYXNzZXNdTlNNdXRhYmxlRGF0YaMdHyBWTlNEYXRhWE5TT2JqZWN00hscIiNcTlNEaWN0aW9uYXJ5oiIgXxAPTlNLZXllZEFyY2hpdmVy0SYnVHJvb3SAAQAIABEAGgAjAC0AMgA3AEAARgBNAFUAYABnAGoAbABuAHEAcwB1AHcAhACOAKYAqwCzAnsCfQKCAo0ClgKkAqgCrwK4Ar0CygLNAt8C4gLnAAAAAAAAAgEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAuk=}, Bdsk-Url-1 = {http://www.sciencedirect.com/science/article/B6V17-511TN7T-1/2/ea5faf2030ad3a65e517e9b8a0c6a2bf}, Bdsk-Url-2 = {http://dx.doi.org/10.1016/j.scico.2010.09.001}}
Enforcing Structural Regularities in Software using IntensiVE
J. Brichau and A. Kellens and S. Castro and T. D'Hondt. Science of Computer Programming: Experimental Software and Toolkits (EST 3). V. 75 N. 4 P. 232-246 (April, 2010).  @article{2010-scico-brichau, Abstract = {The design and implementation of a software system is often governed by a variety of coding conventions, design patterns, architectural guidelines, design rules, and other so-called structural regularities. To prevent a deterioration of the system's source code, it is important that these regularities are verified and enforced upon evolution of the system. The Intensional Views Environment (IntensiVE), presented in this article, is a tool suite for specifying relevant structural regularities in an (object-oriented) software system and verifying them against the current and later versions of the system. At the heart of the IntensiVE tool suite are (logic) program queries and the model of intensional views and relations, through which regularities are expressed. Upon verification of these regularities in the source code of the system, IntensiVE reports the code entities (i.e. classes, methods, variables, statements, etc.) that violate these constraints. We present IntensiVE and illustrate its application to the verification of an Abstract Factory design pattern in the implementation of a software system.}, Annote = {Castro_publication}, Author = {Johan Brichau and Andy Kellens and Sergio Castro and Theo {D'Hondt}}, Date-Added = {2010-11-10 19:52:38 +0100}, Date-Modified = {2014-04-19 23:19:05 +0000}, Journal = {Science of Computer Programming: Experimental Software and Toolkits (EST 3)}, Keywords = {software evolution, logic meta programming, structural regularities}, Month = {April}, Number = {4}, Pages = {232-246}, Title = {Enforcing Structural Regularities in Software using IntensiVE}, Volume = {75}, Year = {2010}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFjIwMTAtc2NpY28tYnJpY2hhdS5wZGbSFwsYGVdOUy5kYXRhTxEBxgAAAAABxgACAAAMTWFjaW50b3NoIEhEAAAAAAAAAAAAAAAAAAAAzeTDuUgrAAAACte5FjIwMTAtc2NpY28tYnJpY2hhdS5wZGYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK19DGHy02AAAAAAAAAAAAAQACAAAJIAAAAAAAAAAAAAAAAAAAAAZwYXBlcnMAEAAIAADN5KeZAAAAEQAIAADGHxEWAAAAAQAUAArXuQAKvsgACiNDAAoNdwAKDWsAAgBQTWFjaW50b3NoIEhEOlVzZXJzOgBzZXJnaW9jOgBEb2N1bWVudHM6AHJlc2VhcmNoOgBwYXBlcnM6ADIwMTAtc2NpY28tYnJpY2hhdS5wZGYADgAuABYAMgAwADEAMAAtAHMAYwBpAGMAbwAtAGIAcgBpAGMAaABhAHUALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAD5Vc2Vycy9zZXJnaW9jL0RvY3VtZW50cy9yZXNlYXJjaC9wYXBlcnMvMjAxMC1zY2ljby1icmljaGF1LnBkZgATAAEvAAAVAAIADv//AACABtIbHB0eWiRjbGFzc25hbWVYJGNsYXNzZXNdTlNNdXRhYmxlRGF0YaMdHyBWTlNEYXRhWE5TT2JqZWN00hscIiNcTlNEaWN0aW9uYXJ5oiIgXxAPTlNLZXllZEFyY2hpdmVy0SYnVHJvb3SAAQAIABEAGgAjAC0AMgA3AEAARgBNAFUAYABnAGoAbABuAHEAcwB1AHcAhACOAKcArAC0An4CgAKFApACmQKnAqsCsgK7AsACzQLQAuIC5QLqAAAAAAAAAgEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAuw=}}
Diagnosis and Correction of Structural Design Inconsistencies in Software
S. Castro. Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Clapiers, France. (April, 2010).  @misc{2010-sattose-castro, Annote = {Castro_publication}, Author = {S. Castro}, Date-Added = {2008-05-21 00:37:15 +0200}, Date-Modified = {2014-04-19 23:18:32 +0000}, Howpublished = {Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Clapiers, France}, Keywords = {inconsistency management}, Month = {April}, Title = {Diagnosis and Correction of Structural Design Inconsistencies in Software}, Year = {2010}}
Generation and Composition of Corrective Actions to Code Design Problems with Heal
S. Castro and A. Kellens and C. De Roover and K. Mens. 9th BElgian-NEtherlands EVOLution Workshop (BENEVOL). Lille, France. (2010).  @inproceedings{2010-benevol-castro, Abstract = {Maintaining consistency between design and implementation is a fundamental issue in software evolution. Although a certain number of existing tools and techniques provide support for correcting inconsistencies when found, they target generally-applicable design rules. Unfortunately, in addition to these common design rules, any software system has an abundance of custom design rules that are very specific to the system at hand. For such custom design rules, verification and correction are often left to the developer or require a considerable investment in the implementation of specific verification and correction metaprograms. HEAL is a framework that alleviates the problem of diagnosing and correcting violations of custom design rules in code. It supports the implementation and automatic inference of corrective actions (i.e. a program transformation) that may solve a detected design inconsistency. Using an abductive logic reasoner, HEAL infers these corrective actions from the design rules themselves and the code over which these rules are verified. In a previous work we show how simple solutions are generated from a repository of corrective actions to low level structural problems. In this work, we give one additional step showing that multiple solutions affecting the same source code element can be composed, presenting to the programmer the complete vision of how the source code would look like after executing a set of corrective actions.}, Annote = {Castro_publication}, Author = {S. Castro and A. Kellens and C. {De Roover} and K. Mens}, Booktitle = {9th BElgian-NEtherlands EVOLution Workshop (BENEVOL). Lille, France}, Date-Added = {2011-03-13 12:12:57 +0100}, Date-Modified = {2014-05-18 11:36:26 +0000}, Keywords = {inconsistency management, abductive reasoning, logic meta programming}, Title = {Generation and Composition of Corrective Actions to Code Design Problems with Heal}, Year = {2010}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFzIwMTAtYmVuZXZvbC1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAcwAAAAAAcwAAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuRcyMDEwLWJlbmV2b2wtY2FzdHJvLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtfPyQCxagAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAyQCjWgAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIAUU1hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDEwLWJlbmV2b2wtY2FzdHJvLnBkZgAADgAwABcAMgAwADEAMAAtAGIAZQBuAGUAdgBvAGwALQBjAGEAcwB0AHIAbwAuAHAAZABmAA8AGgAMAE0AYQBjAGkAbgB0AG8AcwBoACAASABEABIAP1VzZXJzL3Nlcmdpb2MvRG9jdW1lbnRzL3Jlc2VhcmNoL3BhcGVycy8yMDEwLWJlbmV2b2wtY2FzdHJvLnBkZgAAEwABLwAAFQACAA7//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgCoAK0AtQKFAocCjAKXAqACrgKyArkCwgLHAtQC1wLpAuwC8QAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAALz}}
Diagnosis and Semi-automatic Correction of Detected Design Inconsistencies in Source Code
S. Castro and J. Brichau and K. Mens. International Workshop on Smalltalk Technologies (IWST)Brest, France (August, 2009).  @inproceedings{2009-iwst-castro, Abstract = {In order to alleviate design decay, different program design documentation techniques are used for the specification and detection of design inconsistencies in code. However, these design documentation techniques do not always provide support for the diagnosis and (semi-) automatic correction of such inconsistencies. In case they do, corrective solutions are typically targeted to a reduced set of pre-defined inconsistency problems, and they are not easily customizable to new kinds of consistency checks defined by a user. In particular, they cannot infer possible corrective actions to solve new user-defined inconsistency problems. In this paper, we present a technique for the diagnosis and (semi-) automatic correction of inconsistencies in the context of an existing tool for inconsistency management: IntensiVE. Our technique uses logic abductive reasoning to infer solutions to detected user-defined inconsistencies, starting from basic composable corrective actions. A first prototype implementing our technique on top of IntensiVE is shown.}, Address = {Brest, France}, Annote = {Castro_publication}, Author = {S. Castro and J. Brichau and K. Mens}, Booktitle = {International Workshop on Smalltalk Technologies (IWST)}, Date-Added = {2010-02-10 01:25:08 +0100}, Date-Modified = {2014-04-19 23:19:15 +0000}, Keywords = {Design inconsistency, diagnosis, correction, abductive reasoning , IntensiVE, SOUL, Smalltalk}, Month = {August}, Title = {Diagnosis and Semi-automatic Correction of Detected Design Inconsistencies in Source Code}, Year = {2009}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFDIwMDktaXdzdC1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAb4AAAAAAb4AAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuRQyMDA5LWl3c3QtY2FzdHJvLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtfOxri2VAAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAxriaNAAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIATk1hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDA5LWl3c3QtY2FzdHJvLnBkZgAOACoAFAAyADAAMAA5AC0AaQB3AHMAdAAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgA8VXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMDktaXdzdC1jYXN0cm8ucGRmABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4ApQCqALICdAJ2AnsChgKPAp0CoQKoArECtgLDAsYC2ALbAuAAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAAC4g==}}
Inconsistency Management in Source Code with Abductive Logic Programming
S. Castro. Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Baie de Somme, France. (May, 2009).  @misc{2009-sattose-castro, Annote = {Castro_publication}, Author = {S. Castro}, Date-Added = {2010-07-25 15:29:23 +0200}, Date-Modified = {2014-04-19 23:19:19 +0000}, Howpublished = {Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Baie de Somme, France}, Keywords = {inconsistency management}, Month = {May}, Title = {Inconsistency Management in Source Code with Abductive Logic Programming}, Year = {2009}}
Towards a Unifying Conceptual Framework for Inconsistency Management Approaches: Definitions and Instantiations
A. Hubaux and A. Cleve and P. Schobbens and A. Keller and O. Muliawan and S. Castro and K. Mens and D. Deridder and R. V. D. Straeten. Research reportFUNDP, Namur. Faculté d'Informatiquehttp://www.info.fundp.ac.be/~acl/P-CS-TR-WP4CM-000001.pdf (2009).  @techreport{2009-fundp-hubaux, Abstract = {The problem of managing inconsistencies in and between models is omnipresent in software engineering. Over the years many different inconsistency management approaches have been proposed by the research community. Because of the large diversity of backgrounds from which these approaches originate, it is difficult to pinpoint what they have in common and what not. As a result, researchers encounter difficulties when they want to position and compare their work with existing state-of-the-art, or when they collaborate on or combine different approaches. Also, end-users have a hard time to make an informed decision when selecting the most appropriate approaches. To address these problems, we propose a unifying conceptual framework of definitions and terminology, independent of any concrete inconsistency management approach or (modelling) language. This reference framework allows to gain a common understanding of what inconsistency management involves, what an inconsistency really means, and what the possible causes of an inconsistency can be. We demonstrate the genericity and usefulness of the framework by providing concrete instantiations of it to four different inconsistency management approaches. }, Address = {http://www.info.fundp.ac.be/~acl/P-CS-TR-WP4CM-000001.pdf}, Annote = {Castro_publication}, Author = {A. Hubaux and A. Cleve and P. Schobbens and A. Keller and O. Muliawan and S. Castro and K. Mens and D. Deridder and R. Van Der Straeten}, Date-Added = {2010-07-25 15:20:16 +0200}, Date-Modified = {2014-04-19 23:19:27 +0000}, Institution = {FUNDP, Namur. Facult{\'e} d'Informatique}, Keywords = {Inconsistency management, conceptual framework}, Title = {Towards a Unifying Conceptual Framework for Inconsistency Management Approaches: Definitions and Instantiations}, Type = {Research report}, Year = {2009}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFTIwMDktZnVuZHAtaHViYXV4LnBkZtIXCxgZV05TLmRhdGFPEQHEAAAAAAHEAAIAAAxNYWNpbnRvc2ggSEQAAAAAAAAAAAAAAAAAAADN5MO5SCsAAAAK17kVMjAwOS1mdW5kcC1odWJhdXgucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArXzcYvtMwAAAAAAAAAAAABAAIAAAkgAAAAAAAAAAAAAAAAAAAABnBhcGVycwAQAAgAAM3kp5kAAAARAAgAAMYvmKwAAAABABQACte5AAq+yAAKI0MACg13AAoNawACAE9NYWNpbnRvc2ggSEQ6VXNlcnM6AHNlcmdpb2M6AERvY3VtZW50czoAcmVzZWFyY2g6AHBhcGVyczoAMjAwOS1mdW5kcC1odWJhdXgucGRmAAAOACwAFQAyADAAMAA5AC0AZgB1AG4AZABwAC0AaAB1AGIAYQB1AHgALgBwAGQAZgAPABoADABNAGEAYwBpAG4AdABvAHMAaAAgAEgARAASAD1Vc2Vycy9zZXJnaW9jL0RvY3VtZW50cy9yZXNlYXJjaC9wYXBlcnMvMjAwOS1mdW5kcC1odWJhdXgucGRmAAATAAEvAAAVAAIADv//AACABtIbHB0eWiRjbGFzc25hbWVYJGNsYXNzZXNdTlNNdXRhYmxlRGF0YaMdHyBWTlNEYXRhWE5TT2JqZWN00hscIiNcTlNEaWN0aW9uYXJ5oiIgXxAPTlNLZXllZEFyY2hpdmVy0SYnVHJvb3SAAQAIABEAGgAjAC0AMgA3AEAARgBNAFUAYABnAGoAbABuAHEAcwB1AHcAhACOAKYAqwCzAnsCfQKCAo0ClgKkAqgCrwK4Ar0CygLNAt8C4gLnAAAAAAAAAgEAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAuk=}}
Diagnosis and Correction of Structural Design Inconsistencies in Software
S. Castro and A. Kellens and C. D. Roover and K. Mens. 8th BElgian-NEtherlands EVOLution Workshop (BENEVOL). Louvain-la-Neuve, Belgium. (2009).  @unpublished{2009-benevol-castro, Annote = {Castro_publication}, Author = {Sergio Castro and Andy Kellens and Coen De Roover and Kim Mens}, Booktitle = {8th BElgian-NEtherlands EVOLution Workshop (BENEVOL). Louvain-la-Neuve, Belgium}, Date-Added = {2011-03-28 01:58:43 +0200}, Date-Modified = {2014-05-18 11:52:07 +0000}, Keywords = {Logic Abduction}, Title = {Diagnosis and Correction of Structural Design Inconsistencies in Software}, Year = {2009}}
Towards Semi-automatic Inconsistency Management between Design Regularities and Source Code
S. Castro. Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Waulsort, Belgium. (February, 2008).  @misc{2008-sattose-castro, Annote = {Castro_publication}, Author = {S. Castro}, Date-Added = {2010-07-25 15:29:28 +0200}, Date-Modified = {2014-04-19 23:19:31 +0000}, Howpublished = {Seminar on Advanced Tools and Techniques for Software Evolution (SATToSE). Waulsort, Belgium}, Keywords = {inconsistency management}, Month = {February}, Title = {Towards Semi-automatic Inconsistency Management between Design Regularities and Source Code}, Year = {2008}}
Enforcing Structural Regularities in Software using IntensiVE
J. Brichau and A. Kellens and S. Castro and T. D'Hondt. International Workshop on Advanced Software Development Tools and Techniques (WASDeTT). Co-located with the European Conference in Object-Oriented Programming (ECOOP). (2008).  @inproceedings{2008-wasdett-brichau, Abstract = {The design and implementation of a software system is often governed by many different coding conventions, design patterns, architectural design rules, and other so-called structural regularities. To prevent a deterioration of the system's source code, it is important that these regularities are verified and enforced in subsequent evolutions of the system. The Intensional Views Environment (IntensiVE), presented in this article, is a tool suite for documenting such structural regularities in (object-oriented) software systems and verifying their consistency in later versions of those systems.}, Annote = {Castro_publication}, Author = {J. Brichau and A. Kellens and S. Castro and T. D'Hondt}, Booktitle = {International Workshop on Advanced Software Development Tools and Techniques (WASDeTT). Co-located with the European Conference in Object-Oriented Programming (ECOOP)}, Date-Added = {2008-05-29 15:56:18 +0200}, Date-Modified = {2014-04-19 23:19:35 +0000}, Keywords = {software evolution, logic metaprogramming, software documentation}, Title = {Enforcing Structural Regularities in Software using IntensiVE}, Year = {2008}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QGDIwMDgtd2FzZGV0dC1icmljaGF1LnBkZtIXCxgZV05TLmRhdGFPEQHOAAAAAAHOAAIAAAxNYWNpbnRvc2ggSEQAAAAAAAAAAAAAAAAAAADN5MO5SCsAAAAK17kYMjAwOC13YXNkZXR0LWJyaWNoYXUucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAArXzMRhmhQAAAAAAAAAAAABAAIAAAkgAAAAAAAAAAAAAAAAAAAABnBhcGVycwAQAAgAAM3kp5kAAAARAAgAAMRhffQAAAABABQACte5AAq+yAAKI0MACg13AAoNawACAFJNYWNpbnRvc2ggSEQ6VXNlcnM6AHNlcmdpb2M6AERvY3VtZW50czoAcmVzZWFyY2g6AHBhcGVyczoAMjAwOC13YXNkZXR0LWJyaWNoYXUucGRmAA4AMgAYADIAMAAwADgALQB3AGEAcwBkAGUAdAB0AC0AYgByAGkAYwBoAGEAdQAuAHAAZABmAA8AGgAMAE0AYQBjAGkAbgB0AG8AcwBoACAASABEABIAQFVzZXJzL3Nlcmdpb2MvRG9jdW1lbnRzL3Jlc2VhcmNoL3BhcGVycy8yMDA4LXdhc2RldHQtYnJpY2hhdS5wZGYAEwABLwAAFQACAA7//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgCpAK4AtgKIAooCjwKaAqMCsQK1ArwCxQLKAtcC2gLsAu8C9AAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAAL2}}
Towards a Taxonomy of Tools for Documenting Code Design
S. Castro and K. Mens and J. Brichau. Query Technologies and Applications for Program Comprehension (QTAPC). Collocated Workshop at the IEEE International Conference on Program Comprehension (ICPC). (2008).  @inproceedings{2008-qtapc-icpc-castro, Abstract = {Numerous tools for documenting code design exist. Each of these proposes different techniques and attempts to deal with different aspects regarding code design documenta- tion. Though this abundance of tools and techniques is a clear sign of the importance of such kind of tools in real life software implementation, it also creates confusion when trying to decide which one best suites the specific needs of a project. Adding to this confusion is the fact that different tools often use a different terminology for similar problems. Furthermore, the support offered by most of these tools is limited, since it is often based either on verifiable documen- tation that is not highly customizable, or customizable doc- umentation that cannot easily be verified. This paper takes initial steps in the direction of establishing a common vo- cabulary for describing code design documentation tools, and highlights the features that a verifiable and highly cus- tomizable tool should provide in order to satisfy most of the code design documentation requirements present in the im- plementation of complex software systems. }, Annote = {Castro_publication}, Author = {S. Castro and K. Mens and J. Brichau}, Booktitle = {Query Technologies and Applications for Program Comprehension (QTAPC). Collocated Workshop at the IEEE International Conference on Program Comprehension (ICPC)}, Date-Added = {2008-05-20 22:12:10 +0200}, Date-Modified = {2014-04-19 23:19:43 +0000}, Keywords = {taxonomy code design documentation}, Title = {Towards a Taxonomy of Tools for Documenting Code Design}, Year = {2008}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QGjIwMDgtcXRhcGMtaWNwYy1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAdYAAAAAAdYAAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuRoyMDA4LXF0YXBjLWljcGMtY2FzdHJvLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtfLxFD2ngAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAxFDafgAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIAVE1hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDA4LXF0YXBjLWljcGMtY2FzdHJvLnBkZgAOADYAGgAyADAAMAA4AC0AcQB0AGEAcABjAC0AaQBjAHAAYwAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgBCVXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMDgtcXRhcGMtaWNwYy1jYXN0cm8ucGRmABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4AqwCwALgCkgKUApkCpAKtArsCvwLGAs8C1ALhAuQC9gL5Av4AAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAADAA==}}
The IntensiVE Tool Suite
J. Brichau and A. Kellens and K. Mens and S. Castro. Working Conference on Reverse Engineering (WCRE). (2008).  @misc{2008-wcre-brichau, Annote = {Castro_publication}, Author = {J. Brichau and A. Kellens and K. Mens and S. Castro}, Date-Added = {2011-03-28 19:53:51 +0200}, Date-Modified = {2014-04-19 23:19:39 +0000}, Howpublished = {Working Conference on Reverse Engineering (WCRE)}, Keywords = {IntensiVE}, Title = {The IntensiVE Tool Suite}, Year = {2008}}
Towards an Automated Tool for Correcting Design Decay
S. Castro and J. Brichau and K. Mens. 7th BElgian-NEtherlands EVOLution Workshop (BENEVOL). Eindhoven, Netherlands. (2008).  @unpublished{2008-benevol-castro, Annote = {Castro_publication}, Author = {S. Castro and J. Brichau and K. Mens}, Booktitle = {7th BElgian-NEtherlands EVOLution Workshop (BENEVOL). Eindhoven, Netherlands}, Date-Added = {2011-03-28 01:38:57 +0200}, Date-Modified = {2014-05-18 11:52:52 +0000}, Keywords = {Logic Abduction}, Title = {Towards an Automated Tool for Correcting Design Decay}, Year = {2008}}
A Unified Mechanism for Improving Advanced Transaction Management in Web Services
S. Castro and J. Fabry and K. Mens and T. D'Hondt. XXVI International Conference of the Chilean Computer Science Society (ICCC). Editor: IEEE Computer SocietyIquique, Chile (November, 2007).  @conference{2007-sccc-castro, Abstract = {Current web-service composition languages, such as BPEL, provide inferior support for transaction management. Consequently, specifications written in these languages are need- lessly complex and hard to reuse. Furthermore, the languages themselves are not extensible, making them hard to adapt to support new forms of web service composition. Using a unified mechanism for dealing with transaction management we are able to simplify BPEL specifications, making them more reusable, and also allowing easy evolution of the language, addressing new forms of composition. In this paper we present DBCF, a framework that implements this unified mechanism. Moreover, we show how DBCF can be used as a basis for defining a BPEL extension that successfully addresses the above problems.}, Address = {Iquique, Chile}, Annote = {Castro_publication}, Author = {S. Castro and J. Fabry and K. Mens and T. {D'Hondt}}, Booktitle = {XXVI International Conference of the Chilean Computer Science Society (ICCC)}, Date-Added = {2008-01-09 21:49:48 +0100}, Date-Modified = {2014-04-19 23:19:51 +0000}, Editor = {IEEE Computer Society}, Keywords = {Web Services composition, ACTA, KALA, Distributed programming}, Month = {November}, Rating = {3}, Read = {Yes}, Title = {A Unified Mechanism for Improving Advanced Transaction Management in Web Services}, Year = {2007}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QFDIwMDctc2NjYy1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAb4AAAAAAb4AAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuRQyMDA3LXNjY2MtY2FzdHJvLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtfKwtzsdgAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAwtzQVgAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIATk1hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDA3LXNjY2MtY2FzdHJvLnBkZgAOACoAFAAyADAAMAA3AC0AcwBjAGMAYwAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgA8VXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMDctc2NjYy1jYXN0cm8ucGRmABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4ApQCqALICdAJ2AnsChgKPAp0CoQKoArECtgLDAsYC2ALbAuAAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAAC4g==}}
Acta Dependencies As A Unified Mechanism For Compensation, Activities Synchronization And Functional Replication In BPEL4Ws
S. Castro. Vrije Universiteit Brussel (Belgium), Ecole des Mines de Nantes (France)Master thesis. (August, 2006).  @mastersthesis{2006-mastherthesis-castro, Abstract = {Advanced transaction management in loosely coupled environments is not a trivial task. Web Services are the current state of the art for interoperability for such kind of systems, and the BPEL4WS language is nowadays the de facto standard for web services composi- tion in industry. However, the BPEL4WS strategy for expressing transactional properties is limited, non extensible, and relies on different unrelated constructs for managing the concerns of activity synchronization, functional replication and activity compensation. We believe that these concerns should be managed using a more simpler, extensible and unified set of constructs, relying on well proved existing formal models for advanced transaction management. In this work we introduce such a composition framework called DBCF (De- pendency Based Composition Framework). DBCF demonstrates the viability of our con- ceptual model in service composition languages. In addition, we present an extension for BPEL4WS that adds these features, and suggest ways of describing declaratively transac- tional properties expressed with our proposed extension using aspect oriented technologies. }, Annote = {Castro_publication}, Author = {S. Castro}, Date-Added = {2008-01-09 23:41:59 +0100}, Date-Modified = {2014-04-19 23:19:56 +0000}, Keywords = {Web Services composition, KALA, ACTA, Distributed programming}, Month = {August}, Rating = {3}, Read = {Yes}, School = {Vrije Universiteit Brussel (Belgium), Ecole des Mines de Nantes (France)}, Title = {Acta Dependencies As A Unified Mechanism For Compensation, Activities Synchronization And Functional Replication In BPEL4Ws}, Type = {Master thesis}, Year = {2006}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QHTIwMDYtbWFzdGhlcnRoZXNpcy1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAeQAAAAAAeQAAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuR0yMDA2LW1hc3RoZXJ0aGVzaXMtY2FzdHJvLnBkZgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtfJyb5soQAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAyb5QgQAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIAV01hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDA2LW1hc3RoZXJ0aGVzaXMtY2FzdHJvLnBkZgAADgA8AB0AMgAwADAANgAtAG0AYQBzAHQAaABlAHIAdABoAGUAcwBpAHMALQBjAGEAcwB0AHIAbwAuAHAAZABmAA8AGgAMAE0AYQBjAGkAbgB0AG8AcwBoACAASABEABIARVVzZXJzL3Nlcmdpb2MvRG9jdW1lbnRzL3Jlc2VhcmNoL3BhcGVycy8yMDA2LW1hc3RoZXJ0aGVzaXMtY2FzdHJvLnBkZgAAEwABLwAAFQACAA7//wAAgAbSGxwdHlokY2xhc3NuYW1lWCRjbGFzc2VzXU5TTXV0YWJsZURhdGGjHR8gVk5TRGF0YVhOU09iamVjdNIbHCIjXE5TRGljdGlvbmFyeaIiIF8QD05TS2V5ZWRBcmNoaXZlctEmJ1Ryb290gAEACAARABoAIwAtADIANwBAAEYATQBVAGAAZwBqAGwAbgBxAHMAdQB3AIQAjgCuALMAuwKjAqUCqgK1Ar4CzALQAtcC4ALlAvIC9QMHAwoDDwAAAAAAAAIBAAAAAAAAACgAAAAAAAAAAAAAAAAAAAMR}}
Analysis, Design and Implementation of a Code Generator System for the Interpretation of Distinct Call Detail Records (CDRs) Formats
S. Castro and W. Maldonado. Escuela Superior Politécnica del Litoral (ESPOL) (Ecuador)Engineering thesis. (December, 2004).  @mastersthesis{2004-engineeringhesis-castro, Abstract = {This thesis describes the initial module of a complex Convergent Mediation system. Its implementation has been successfully deployed in an Ecuadorian Telecom company. The main technologies involved in the system were Java and XML related specifications.}, Annote = {Castro_publication}, Author = {S. Castro and W. Maldonado}, Date-Added = {2011-03-01 10:42:13 +0100}, Date-Modified = {2014-04-19 23:20:00 +0000}, Month = {December}, School = {Escuela Superior Polit{\'e}cnica del Litoral (ESPOL) (Ecuador)}, Title = {Analysis, Design and Implementation of a Code Generator System for the Interpretation of Distinct Call Detail Records (CDRs) Formats}, Type = {Engineering thesis}, Year = {2004}, Bdsk-File-1 = {YnBsaXN0MDDUAQIDBAUGJCVYJHZlcnNpb25YJG9iamVjdHNZJGFyY2hpdmVyVCR0b3ASAAGGoKgHCBMUFRYaIVUkbnVsbNMJCgsMDxJXTlMua2V5c1pOUy5vYmplY3RzViRjbGFzc6INDoACgAOiEBGABIAFgAdccmVsYXRpdmVQYXRoWWFsaWFzRGF0YV8QIDIwMDQtZW5naW5lZXJpbmdoZXNpcy1jYXN0cm8ucGRm0hcLGBlXTlMuZGF0YU8RAe4AAAAAAe4AAgAADE1hY2ludG9zaCBIRAAAAAAAAAAAAAAAAAAAAM3kw7lIKwAAAArXuR8yMDA0LWVuZ2luZWVyaW5naGVzaXMjQUQ3QzgucGRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACtfIycDs8gAAAAAAAAAAAAEAAgAACSAAAAAAAAAAAAAAAAAAAAAGcGFwZXJzABAACAAAzeSnmQAAABEACAAAycDQ0gAAAAEAFAAK17kACr7IAAojQwAKDXcACg1rAAIAWU1hY2ludG9zaCBIRDpVc2VyczoAc2VyZ2lvYzoARG9jdW1lbnRzOgByZXNlYXJjaDoAcGFwZXJzOgAyMDA0LWVuZ2luZWVyaW5naGVzaXMjQUQ3QzgucGRmAAAOAEIAIAAyADAAMAA0AC0AZQBuAGcAaQBuAGUAZQByAGkAbgBnAGgAZQBzAGkAcwAtAGMAYQBzAHQAcgBvAC4AcABkAGYADwAaAAwATQBhAGMAaQBuAHQAbwBzAGgAIABIAEQAEgBIVXNlcnMvc2VyZ2lvYy9Eb2N1bWVudHMvcmVzZWFyY2gvcGFwZXJzLzIwMDQtZW5naW5lZXJpbmdoZXNpcy1jYXN0cm8ucGRmABMAAS8AABUAAgAO//8AAIAG0hscHR5aJGNsYXNzbmFtZVgkY2xhc3Nlc11OU011dGFibGVEYXRhox0fIFZOU0RhdGFYTlNPYmplY3TSGxwiI1xOU0RpY3Rpb25hcnmiIiBfEA9OU0tleWVkQXJjaGl2ZXLRJidUcm9vdIABAAgAEQAaACMALQAyADcAQABGAE0AVQBgAGcAagBsAG4AcQBzAHUAdwCEAI4AsQC2AL4CsAKyArcCwgLLAtkC3QLkAu0C8gL/AwIDFAMXAxwAAAAAAAACAQAAAAAAAAAoAAAAAAAAAAAAAAAAAAADHg==}}

Teaching

Below are some of the courses I have been involved in as a tutor during my academic life.

Courses

Institution Code of the course Description Position
UCL INGI2252 Software measures, metrics and maintenance. Target language: Smalltalk (Pharo). PhD candidate/teaching assistant
UCL SINFINFO2255 Software development project. PhD candidate/teaching assistant
UCL LSINF1225 Object-oriented design and data management. Platform: Android. PhD candidate/teaching assistant
UCL LSINF1161 Introduction to programming and the object orientation paradigm. Target language: Java. PhD candidate/teaching assistant
UCL LSINF1151 Computer aided problem resolution. Target language: Java. PhD candidate/teaching assistant

Theses guidance

I have collaborated as a reader and co-advisor of the following master theses:

Implementing context-aware mobile applications through dynamic reification of a database model.
Espoir Gahungere. Université catholique de Louvain. Promoter: Prof. Kim Mens, Sergio Castro. 2013.
Un Outil d'Analyse de la Qualité du Code Destiné aux Étudiants de Première Année de Baccalauréat.
Nicolas Muller. Université catholique de Louvain. Promoter: Prof. Kim Mens. 2010.
Definition and Verification of Structural Regularities in Enterprise Java Beans Applications
Laurent Lantsoght. Université catholique de Louvain. Promoter: Prof. Kim Mens. 2009.