@conference {98, title = {Language-Shifting Objects in Inter-language Interoperability}, booktitle = {Proceedings of the International Workshop on Smalltalk Technologies (IWST09)}, year = {2009}, abstract = {

Foreign-function interfaces enable programs in a host language to interoperate with programs written in another language and vice-versa. Two languages that feature such an interface to a common language can even interoperate by means of this common intermediate language. Smalltalk and Java, for example, both offer an interface to C and can therefore interoperate through a connection of these interfaces. However, the resulting interactions will need to occur at the level of abstraction offered by the (low-level) C interfaces, although both Java and Smalltalk are object-oriented languages. In this paper, we describe how the dynamic and reflective facilities of the Smalltalk language permit to raise the level of abstraction of these inter-language interactions to seamless message passing between objects. In addition, we introduce and explore the concept of language shifting objects where Java objects are not only represented in Smalltalk but can partially or completely migrate from Java to Smalltalk. Language-shifting effectively migrates Java methods to Smalltalk methods such that original Java objects can end up {\textquoteleft}{\textquoteleft}living{\textquoteright}{\textquoteright} in the Smalltalk environment without needing a connection to their originating Java environment.

}, keywords = {interconnect, interoperability, java, java smalltalk symbiosis, javaconnect, linguistic symbiosis, smalltalk, symbiosis}, author = {Johan Brichau and Coen De Roover} } @conference {102, title = {Example-based Program Querying}, booktitle = {Proceedings of the 2008 Working Session on Query Technologies and Applications for Program Comprehension (QTAPC08) at the 16th International Conference on Program Comprehension (ICPC08)}, year = {2008}, abstract = {

Program query languages are an essential component of program analysis and manipulation systems. In each such system, a query identifies the source-code parts of interest by reasoning over a program representation that is dedi- cated to the intent of the system (e.g. call-graphs to de- tect behavioral flaws, abstract syntax trees for refactorings, concrete source code to verify programming conventions, etc.). In order to detect a wide variety of such {\textquoteleft}{\textquoteleft}patterns of interest{\textquoteright}{\textquoteright}, or more importantly, to detect patterns that re- quire a combination of such program representations, de- velopers must understand all the different applicable rep- resentations and techniques. We therefore present a logic- based language that allows the program{\textquoteright}s implementation to be queried using concrete source code templates that are matched against a combination of structural and behavioral program representations. These representations include call-graphs, points-to analysis results and abstract syntax trees that are uniformly composed through a customizable unification procedure. The result of our approach is that de- velopers can detect patterns in the queried program using source code excerpts (embedded in logic queries) which act as prototypical samples of the structure and behavior they intend to match.

}, keywords = {example-based, lmp, logic meta programming, pattern detection, prolog, templates}, author = {Kellens, Andy and Johan Brichau and Coen De Roover} } @conference {105, title = {Behavioral Similarity Matching using Concrete Source Code Templates in Logic Queries}, booktitle = {Proceedings of the ACM-SIGPLAN Symposium on Partial Evaluation and semantics-based Program Manipulation (PEPM07)}, year = {2007}, abstract = {

Program query languages and pattern-detection techniques are an essential part of program analysis and manipulation systems. Queries and patterns permit the identification of the parts of interest in a program{\textquoteright}s implementation through a representation dedicated to the intent of the system (e.g. call-graphs to detect behavioral flaws, abstract syntax trees for transformations, concrete source code to verify programming conventions, etc). This requires that developers understand and manage all the different representations and techniques in order to detect various patterns of interest. To alleviate this overhead, we present a logic-based language that allows the program{\textquoteright}s implementation to be queried using concrete source code templates. The queries are matched against a combination of structural and behavioral program representations, including call-graphs, points-to analysis results and abstract syntax trees. The result of our approach is that developers can detect patterns in the queried program using source code excerpts (embedded in logic queries) which act as prototypical samples of the structure and behavior they intend to match.

}, keywords = {logic meta programming, pattern detection, program analysis, program querying, program validation, source code templates}, author = {Coen De Roover and Johan Brichau and Carlos Noguera and Theo D{\textquoteright}Hondt and Duchien, Laurence} } @conference {103, title = {Open Unification for Program Query Languages}, booktitle = {Proceedings of the XXVI International Conference of the Chilean Computer Science Society (SCCC 2007)}, year = {2007}, abstract = {

Logic-based programming languages are increasingly applied as \emph{program query languages} which allow developers to reason about the structure and behaviour of programs. To achieve this, the queried programs are reified as logic values such that logic quantification and unification can be used effectively. However, in many cases, standard logic unification is inappropriate for program entities, forcing developers to resort to overly complex queries. In this paper, we argue that such incidental complexity can be reduced significantly by customizing the unification algorithm. We present a practical implementation approach through inter-language reflection and open unification. These techniques are at the core of the logic program query language SOUL, through which we demonstrate custom unification schemes for reasoning over Smalltalk and Java programs. Queries written in this tailored version of SOUL can exploit advanced program matching strategies without increasing the incidental complexity of the queries.

}, keywords = {logic meta programming, open unification, program queries}, author = {Johan Brichau and Coen De Roover and Kim Mens} } @conference {106, title = {Combining Fuzzy Logic and Behavioral Similarity for Non-strict Program Validation}, booktitle = {Proceedings of the 8th ACM-SIGPLAN Symposium on Principles and Practice of Declarative Programming (PPDP06)}, year = {2006}, abstract = {

The quality of an application{\textquoteright}s implementation can be assured by validating the presence or absence of a set of user-prescribed software patterns such as software engineering best practices, programming conventions and indications of poor programming. Most of the existing pattern detection techniques, however, interpret pattern descriptions in an inflexible manner, leaving the quality assurance tool to approve only the most strictly adhering pattern implementations. In order to detect various concrete pattern implementations using a single pattern description, we have combined logic meta programming {\~A}{\textcent}{\^a}{\quotesinglbase}{\textlnot}{\^a}{\texteuro}{\oe}-wherein patterns can be expressed as constraints over facts representing a program{\textquoteright}s source code{\~A}{\textcent}{\^a}{\quotesinglbase}{\textlnot}{\^a}{\texteuro}{\oe}-, fuzzy logic and static program analysis in a way that is completely transparent to the end-user. We have achieved this by having the conditions in a logic rule interpreted as constraints over the run-time behavior source code constructs give rise to instead of as constraints over the literal source code constructs themselves. This way, a pattern{\textquoteright}s abstract description often suffices to recognize various concrete implementation variants with an indication of the similarity between the recognized implementation and the abstract pattern description.

}, keywords = {fuzzy logic programming, logic meta programming, points-to-analysis, program analysis, program validation, quality assurance of object-oriented programs}, isbn = {1-59593-388-3}, author = {Coen De Roover and Johan Brichau and Theo D{\textquoteright}Hondt} } @article {Brichau2006, title = {{A} model curriculum for aspect-oriented software development}, journal = {IEEE Software}, volume = {23}, number = {6}, year = {2006}, note = {Special Issue on Software Engineering Curriculum Development}, month = {November/December}, pages = {53{\~A}{\textcent}{\^a}{\quotesinglbase}{\textlnot}{\^a}{\texteuro}{\oe}61}, abstract = {A model postgraduate curriculum for aspect-oriented software development has been derived from practical experience of running postgraduate courses at nine institutions across Europe (part of the European Network of Excellence on AOSD). Several institutions have made concrete instantiations of the curriculum, from a summer school to part of a university master{\textquoteright}s degree course. The curriculum also relates to the Software Engineering Body of Knowledge. This article is part of a special issue on Software Engineering Curriculum Development.}, keywords = {CSc}, issn = {0740-7459}, doi = {10.1109/MS.2006.146}, author = {Johan Brichau and Ruzanna Chitchyan and Siobh{\~A}{\textflorin}{\^A}{\textexclamdown}n Clarke and Ellie D{\textquoteright}Hondt and Alessandro Garcia and Michael Haupt and Wouter Joosen and Shmuel Katz and Jacques Noy{\~A}{\textflorin}{\^A}{\textcopyright} and Awais Rashid and Mario S{\~A}{\textflorin}{\^A}{\textonequarter}dholt} } @conference {108, title = {Program Testing Using High-Level Property-Driven Models}, booktitle = {Proceedings of the Eighteenth International Conference on Software Engineering and Knowledge Engineering (SEKE06)}, year = {2006}, abstract = {

Testing is a crucial part of the software development life cycle that necessitates adequate techniques and tools. On the one hand, unit or function testing techniques are particularly easy and lightweight to use but are restricted to the testing of the external behaviour of a program. On the other hand, testing techniques that use property-driven models of the software are able to test behavioural properties of the entire execution of a program. However these models are often specified in terms of low-level execution events of the program. In this paper, we present the lightweight propertydriven testing platform called BEHAVE, where tests are written as property-driven behavioural models over highlevel run-time events. We validate our approach by testing behavioural properties related to the automatic memory management in the interpreter of the Pico programming language.

}, keywords = {behave, dynamic analysis, logic meta programming, program testing, program traces, temporal logic, temporal logic programming}, author = {Michiels, Isabel and Coen De Roover and Johan Brichau and Elisa Gonzalez Boix and Theo D{\textquoteright}Hondt} }