Advances in Smalltalk (eBook)

14th International Smalltalk Conference, ISC 2006, Prague, Czech Republic, September 4-8, 2006

Wolfgang De Meuter (Ed.) (Herausgeber)

eBook Download: PDF

2007 | 1. Auflage
165 Seiten
Springer-Verlag
9783540718369 (ISBN)

Infos

This book constitutes the thoroughly refereed post-proceedings of the 14th International Smalltalk Conference, ISC 2006, held in Prague, Czech Republic in September 2006.



The seven revised full papers presented were carefully reviewed and selected from the technical contributions held during the academic track of the conference. Being a live forum on cutting edge software technologies, the conference attracted researchers and professionals from both academia and industry that produced papers covering topics from foundational issues to advanced applications.



Written for: Researchers and professionals



Keywords:

UI frameworks, aspect-oriented programming, component systems, context-awareness, embedded systems, generative programming, meta-modeling, metaobject protocols, metaprogramming, model driven development, object technology, object-oriented languages, object-oriented programming, partial behavioral reflection, refactoring, software product families, traits, visualization

Inhalt

Preface 6
Organization 7
Table of Contents 8
Application-Specific Models and Pointcuts Usinga Logic Met a Language 9
An Object-Oriented Approach for Context-Aware Applications 31
Unanticipated Partial Behavioral Reflection 55
Stateful Traits 74
Scl:A Simple, Uniform and Operational Language for Component-Oriented Programming in Smalltalk 99
Let’s Modularize the Data Model Specifications of the ObjectLens in VisualWorks/Smalltalk 119
Meta-driven Browsers 142
Author Index 165

Textauszug

Application-Specific Models and Pointcuts Using a Logic Meta Language (p. 8)1 Introduction

Aspect-oriented Software Development (AOSD) is a recent, yet established development paradigm that enhances existing development paradigms with advanced encapsulation and modularisation capabilities [1,2]. In particular, aspect-oriented programming languages provide a new kind of abstraction, called aspect, that allows a developer to modularise the implementation of crosscutting concerns such as synchronisation, transaction management, exception handling, etc.

Such concerns are traditionally spread across variousmodules in the implementation, causing tangled and scattered code [3]. The improved modularity and separation of concerns [4], that can be achieved using aspects, intends not only to aid initial development, but also to allow developers to better manage software complexity, evolution and reuse.

One of the most essential characteristics of an aspect-oriented programming language is that aspects are not explicitly invoked but instead, are implicitly invoked [5]. This has also been referred to as the ‘obliviousness’ property of aspect orientation [6]. It means that the base program (i.e., the program without the aspects) does not explicitly invoke the aspects because the aspects themselves specify when and where they need to be invoked by means of a pointcut de.nition.

A pointcut essentially specifies a set of join points, which are specific points in the base program where the aspect will be invoked implicitly. Such a pointcut de.nition typically relies on structural and behavioural properties of the base program to express the intended join points. For example, if an aspect must be triggered at the instantiation of each new object of a particular class, its pointcut must capture those join points whose properties correspond with the execution of the constructor method.

As a result, each time the constructor method is executed (i.e. an instance is created), the aspect is invoked. In most aspect languages, this corresponds to the execution of an advice, which is a sequence of instructions executed before, after or around the execution of the join point. Unfortunately, in many cases, de.ning and maintaining an appropriate pointcut is a rather complex activity.

First of all, an aspect developer must carefully analyse and understand the structure of the entire application and the properties shared by all intended join points in particular. Some of these properties can be directly tied to abstractions that are available in the programming language but other properties are based on programming conventions such as naming schemes. ‘Object instantiation’ join points, for example, can be identified as the execution of constructor methods in languages such as Java.

Accessing methods, however, can be identified only if the developers adhere to a particular naming scheme, such as through put- and get- prefixes in the method names. In contrast, a language such as C# again facilitates the identification of such accessor method join points because they are part of the language structure through the C# ‘properties’ language feature. In essence, we can say that the more structure is available in the implementation, the more properties are available for the definition of pointcuts, effectively facilitating their definition.

Produkt-Details

• Erscheint lt. Verlag: 1.1.2007
• Sprache: englisch
• Themenwelt: Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge
• ISBN-13: 9783540718369 / 9783540718369