Several authors have proposed using code modification as a technique for enforcing security policies such as resource limits, access controls, and network information flows. However, these approaches are typically ad hoc and are implemented without a high level abstract framework for code modification. We propose using reflection as a mechanism for implementing code modifications within an abstract framework based on the semantics of the underlying programming language. We have developed a reflective version of Java called Kava that uses byte-code rewriting techniques to insert pre-dened hooks into Java class les at load time. This makes it possible to specify and implement security policies for mobile code in a more abstract and flexible way. Our mechanism could be used as a more principled way of enforcing some of the existing security policies described in the literature. The advantages of our approach over related work (SASI, JRes, etc.) are that we can guarantee that our security mechanisms cannot be bypassed, a property we call strong non-bypassability, and that our approach provides the high level abstractions needed to build useful security policies.

The applicability of term rewriting to program transformation is limited by the lack of control over rule application and by the context-free nature of rewrite rules. The first problem is addressed by languages supporting user-definable rewriting strategies. This paper addresses the second problem by extending rewriting strategies with scoped dynamic rewrite rules. Dynamic rules are generated at run-time and can access variables available from their definition context. Rules generated within a rule scope are automatically retracted at the end of that scope. The technique is illustrated by means of several program tranformations: bound variable renaming, function inlining, and dead function elimination.

This paper introduces the NODS project been currently conducted at the LSR-IMAG laboratory, Grenoble { France. NODS aims at dening an open, adaptable, evolutionary architecture that can be extended and customized on a per-application basis. A database system is seen as an infrastructure comprised of co-operating adaptable and extensible services from which applications can build their customized NODS database components. Furthermore, services or database systems conguration can be adapted at runtime (e.g., add new services, change services internal policies), according to environmental changes. 1

We analyze how to use the reflective approach to integrate an authorization system into a distributed object-oriented framework. The expected benefits from the reective approach are: more stability of the security layer (i.e., with a more limited number of hidden bugs), better software and development modularity, more reusability, and the possibility to adapt the security module with at most a few changes to other applications. Our analysis is supported by simple and illustrative examples written in Java.

This paper proposes a novel reflective approach, orthogonal to the classic computational approach, whereby a system performs computation on its software architecture instead of individual components. The approach supports system's self-management activities such as dynamic reconfiguration to be realized in a systematic and conceptually clean way and added to existing systems without modifying the system itself. The parallelism between such architectural reflection and classic reflection is discussed, as well as the transposition of classic reflective concepts in the architectural domain.

Traditional methods for object-oriented analysis and modeling focus on the functional specification of software systems, i.e., application domain modeling. Non-functional requirements such as fault-tolerance, distribution, integration with legacy systems, and so on, have no clear collocation within the analysis process, since they are related to the architecture and workings of the system itself rather than the application domain. They are thus addressed in the system's design, based on the partitioning of the system's functionality into classes resulting from analysis. As a consequence, the smooth transition from analysis to design that is usually celebrated as one of the main advantages of the object-oriented paradigm does not actually hold for what concerns non-functional issues. A side e ect is that functional and non-functional concerns tend to be mixed at the implementation level. We argue that the reflective approach whereby non-functional properties are ascribed to a...

Jini offers the basic technology to develop distributed systems where the participating clients, services and their interactions can adapt dynamically to a changing availability and configuration of the network. To monitor the internal processes in such a system a reflection mechanism is necessary. However, the existing reflection mechanisms in Java emerged to be too weak to supply enough information for a suitable management of such a system. Therefore these mechanisms had to be extended by realizing a reflective meta level upon Jini. The tool Carp@ (implemented itself as Jini system) is designed to visualize, analyze and control dynamic and distributed Jini systems. This is done by developing a meta architecture upon a Jini system, that reflects the running Jini system. This paper describes the meta architecture, a tool to monitor it and reports the gained experiences together with their implied consequences.

Traditional methods for object-oriented analysis and modeling focus on the functional specification of software systems. Nonfunctional requirements such as fault-tolerance, distribution, integration with legacy systems, and the like, do not have a clear collocation within the analysis process, as they are related to the architecture and workings of the system itself rather than the application domain. They are thus addressed in the system's design, based on the partitioning of the system's functionality into classes as resulting from the analysis. As a consequence of this, the "smooth transition from analysis to design" that is usually celebrated as one of the main advantages of the object-oriented paradigm does not actually hold for what concerns non-functional issues. Moreover, functional and non-functional concerns tend to be mixed at the implementation level. We argue that the reflective design approach whereby non-functional properties are ascribed to a meta-level of ...

Abstract not found