• 
  ESUG Squeaki

1st Smalltalk Doctoral Symposium
Thursday, August 30th

Essen, Germany

Overview

Participating

• Students that are interested in participating should send their name, affiliation, promotor and an abstract. The abstract should describe the context of the research, the problem that is tackled, and the outline of the solution. It should indicate where Smalltalk is used and the motivation for using it.
• Experienced Smalltalkers or holders of a PhD are invited to join the event and form a committee that will review the abstracts, attend the Doctoral Symposium and give comments on the students' research. Please send a short resumee to rwuyts@iam.unibe.ch.

Participating Students

• Johan Brichau (Programming Technology Lab, Vrije Universiteit Brussel, Belgium)
• Tom Tourwe (Programming Technology Lab, Vrije Universiteit Brussel, Belgium)
• Francisco Garau (Universidad de Buenos Aires, Argentina)
• Olivier Nano
• Frank Gerhardt
• Reza Razavi

Current Programme committee

• Eliot Miranda (Cincom)
• Roel Wuyts (Software Composition Group, University of Bern)
• Serge Stinckwich (University of Caen, France)
• Reiner KŸhl (Tomcat Computer GmbH, Germany)
• Ivan Tomek (Acadia University, Canada)

Abstracts

Johan Brichau (Programming Technology Lab, Vrije Universiteit Brussel, Belgium)

In traditional software development, the software application is recursively decomposed in modularized units (such as functions, classes, packages, etcÉ). This hierarchical decomposition breaks software complexity and facilitates reuse, evolution and maintenance. In an ideal setting, all concerns of the software application should be modularized using an abstraction offered by the programming language. However, some concerns of the software cannot be cleanly encapsulated and are spread throughout every part of the decomposition, i.e., they cross-cut the decomposition. Aspect-Oriented Programming offers a solution by means of language abstractions that support the modularization of such cross-cutting concerns (also called aspects). Logic Meta Programming (LMP) has already been demonstrated as a viable technology for Aspect-Oriented Programming (AOP). Its inate capability of expressing cross-cutting modularity and its declarative nature allow for a concise description of cross-cutting concerns (or aspects). Furthermore, logic rules can be used to build domain-specific aspect languages easily. Last but not least, logic rules enable an expressive aspect combination technique. In our LMP approach, an aspect language is embedded in a logic programming language. This provides a general framework for declaring and implementing aspects. Aspects are declared as logic facts, which annotate the component program with additional declarations or code fragments. The facts trigger logic rules, which reason about the aspects, draw conclusions and finally generate woven output code. The LMP approach to AOP is a framework, that allows users to define, implement and use their own domain-specific aspect languages. The implementation of domain-specific aspect languages (DSALs) is eased because weavers for DSALs do not have to be implemented from scratch. Domain- specific notations can be implemented more easily in terms of more general notations using logic rules that deduce general aspect declarations from more domain-specific ones. Using the language QSOUL (Quasiquoted Smalltalk Open Unification Language), which is an LMP language tightly integrated with (Squeak) Smalltalk, we have developed an AOP-framework in which an aspect is a module of logic rules and facts. A base aspect-module expresses an aspect in low-level declarations that can be understood by the weaver. Such a module can be handed to the weaver that actually integrates the aspect in the component program. The weaver accomplishes this using Smalltalk's metalevel protocol. The AOP framework itself is characterised as follows:

• QSOUL allows to reason about the component program, which automatically enables the aspect programmer to describe the cross-cutting nature of each aspect in terms of every possible location in the component program. Most other aspect languages only allow predefined kinds of cross-cuts.
• Aspects can be made reusable by parameterizing the logic module with another logic module. It boils down to the fact that the aspect module will query another module to obtain some necessary parameters needed to weave the aspect into a concrete component program. In this way, an aspect can be re-used as a black-box entity. A software developer merely needs to create a logic module containing the declarations that are parameters for the aspect.
• Using the same technique, we can specialize aspects for a certain domain through Aspect-Oriented Logic Meta Programming. This technique allows to build domain-specific aspect languages by writing a logic module expressing the logic deductions that translate the higher-level notation into a lower-level notation (e.g. a base aspect). Domain specificity in an aspect language is highly desirable because it results in more concise and more readable aspect declarations. We believe domain-specificity to be of particular interest for aspect languages. Indeed, the first aspect languages were domain specific and not general purpose.
• When multiple aspects need to be integrated into a single component program, their combination can induce problems that are not observed when the aspects are considered in isolation. Therefore, combination and interaction aspects are logic modules that combine two or more logic modules into one and explicitely consider the interaction between the aspects.

The true power of this QSOUL/AOP framework is that the logic paradigm has an innate capability for expressing crosscutting and is at the same time an intuitive and expressive meta-programming paradigm for defining DSALs and addressing aspect-interaction problems.

Tom Tourwe (Programming Technology Lab, Vrije Universiteit Brussel, Belgium)

Francisco Garau (Universidad de Buenos Aires, Argentina): "Concrete Type Inference in Squeak"

Squeak is a language without type declarations; this simplifies and allows exploratory programming. However, concrete type information is a valuable aid to program understanding, application extraction or code optimization. We present the design and implementation in Squeak of a type inference engine that can infer concrete types for some expressions of the language. Our engine can analyze code that includes assignments, inheritance, message sends, primitives, blocks and even #perform:. We extend the definition of concrete type to include the types of instance variables. We add a notion of state to variables and message arguments, that allows us to distinguish the types of their different accesses. We infer types by doing an abstract interpretation over the domain of concrete types, emphasizing the relationship that exists between run-time and inference-time.

Olivier Nano

I'm building Apostle, an aspect-oriented extension for Smalltalk as part of my master's thesis here at the University of British Columbia, under the supervision of Gregor Kiczales. Apostle draws from its big-brother for Java, AspectJ. It has the following three facets:

1. A programmatic interface for manipulating aspects, advice and pointcuts; i.e. making these first-class objects.
2. Proposes extensions to the language to better express these ideas.
3. Engineering a system that cleanly fits into the Smalltalk environment and idioms, namely where any change is immediately reflected throughout the system. For example, redefining a pointcut causes any advice using that pointcut to added or removed from newly- or no-longer-identified program elements.

I've recently made a `pre-release' to solicit feedback, and hope to make a real release soon.

Frank Gerhardt (University of TŸbingen, Germany)

Here is a longer abstract that I wrote for the OOPSLA Doctoral Symposium. For ESUG I'll compress it to a short 1-page abstract.

Reza Razavi: "Why Object-Oriented Languages Should Support Building Tool for Adaptive Object-Models?"

This paper tackles some problems about Adaptive Object Models (a design technique for complex, commercial SMALLTALK applications with important runtime adaptability), as formulated by R. Johnson et al. We show that reflexive object-oriented languages could indeed support a better design and implementation of tools for building Adaptive Object Models. More precisely (1) object-oriented languages without metaclasses, e.g. JAVA, do not support at all a good construction of such tools; (2) SMALLTALK-80 provides some support; (3) a system like Noury Bouraqadi's METACLASSTALK (allowing explicit choice of the metaclass for each class) does provide still a better support for this task.

More information can be found at: http://www-poleia.lip6.fr/~razavi/esug2001/.

Mail comments or questions about this site to the ESUG Webmaster.
Site hosted by TheInternetOne, courtesy of Cees de Groot.