[서평]「Component Software」 - Beyond Object-Oriented Programming -

Context-dependent behavior is becoming increasingly important for a wide range of application domains, from pervasive computing to common business applications. Unfortunately, mainstream programming languages do not provide mechanisms that enable software entities to adapt their behavior dynamically to the current execution context. This leads developers to adopt convoluted designs to achieve the necessary runtime exibility. We propose a new programming technique called Context-oriented Programming (COP) which addresses this problem. COP treats context explicitly, and provides mechanisms to dynamically adapt behavior in reaction to changes in context, even after system deployment at runtime. In this paper, we lay the foundations of COP, show how dynamic layer activation enables multi-dimensional dispatch, illustrate the application of COP by examples in several language extensions, and demonstrate that COP is largely independent of other commitments to programming style.

/pdf/context-oriented-programming-1f235jecqp.pdf

Context-oriented Programming

Join point interception (JPI), is considered an important cornerstone of aspect-oriented languages. However, we claim that JPI alone does not suffice for a modular structuring of aspects. We propose CAESAR, a model for aspect-oriented programming with a higher-level module concept on top of JPI, which enables reuse and componentization of aspects, allows us to use aspects polymorphically, and introduces a novel concept for dynamic aspect deployment.

/pdf/conquering-aspects-with-caesar-3znwt2e3cn.pdf

Conquering aspects with Caesar

When using Aspect Oriented Programming in the development of software components, a developer must understand the program units actually changed by weaving, how they behave, and possibly correct the aspects used. Support for rapid AOP prototyping and debugging is therefore crucial in such situations. Rapid prototyping is difficult with current aspect weaving tools because they do not support dynamic changes. This paper describes PROSE (PROgrammable extenSions of sErvices), a platform based on Java which addresses dynamic AOP. Aspects are expressed in the same source language as the application (Java), and PROSE allows aspects to be woven, unwoven, or replaced at run-time.

https://www.lst.ethz.ch/research/publications/AOSD_2002/AOSD_2002.pdf

Dynamic weaving for aspect-oriented programming

A precise characterization of those security policies enforceable by program rewriting is given. This also exposes and rectifies problems in prior work, yielding a better characterization of those security policies enforceable by execution monitors as well as a taxonomy of enforceable security policies. Some but not all classes can be identified with known classes from computational complexity theory.

/pdf/computability-classes-for-enforcement-mechanisms-eo4k1vath7.pdf

Computability classes for enforcement mechanisms

Support for dynamic and client-specific customization is required in many application areas. We present a (distributed) application as consisting of a minimal functional core — implemented as a component-based system, and an unbound set of potential extensions that can be selectively integrated within this core functionality. An extension to this core may be a new service, due to new requirements of end users. Another important category of extensions we consider, are non-functional services such as authentication, which typically introduce interaction refinements at the application level. In accordance to the separation of concerns principle, each extension is implemented as a layer of mixin-like wrappers. Each wrapper incrementally adds behavior and state to a core component instance from the outside, without modifying the component's implementation. The novelty of this work is that the composition logic, responsible for integrating extensions into the core system, is externalized from the code of clients, core system and extensions. Clients (end users, system integrators) can customize this composition logic on a per collaboration basis by `attaching' high-level interpretable extension identifiers to their interactions with the core system.

Dynamic and selective combination of extensions in component-based applications

In this paper, we present a mechanism to capture and reestablish the state of Java threads. We achieve this by extracting a thread’s execution state from the application code that is executing in this thread. This thread serialization mechanism is implemented by instrumenting the original application code at the byte code level, without modifying the Java Virtual Machine. We describe this thread serialization technique in the context of middleware support for mobile agent technology. We present a simple execution model for agents that guarantees correct thread migration semantics when moving an agent to another location. Our thread serialization mechanism is however generally applicable in other domains as well, such as load balancing and checkpointing.

Portable Support for Transparent Thread Migration in Java

https://link.springer.com/content/pdf/10.1007%2F0-306-46958-8_9.pdf

Security Through Aspect-Oriented Programming

How aspect-oriented programming can help to build secure software

Department of Computer Science, K.U.Leuven

Bart Vanhaute

Papers

Dynamic and selective combination of extensions in component-based applications

Portable Support for Transparent Thread Migration in Java

Security Through Aspect-Oriented Programming

How aspect-oriented programming can help to build secure software

Aspects should not die