The very success and breadth of reflective techniques underscores the need for a general theory of reflection. At present what we have is a wide-ranging variety of reflective systems, each explained in its own idiosyncratic terms. Metalogical foundations can allow us to capture the essential aspects of reflective systems in a formalismindependent way. This paper proposes metalogical axioms for reflective logics and declarative languages based on the theory of general logics [34]. In this way, several strands of work in reflection, including functional, equational, Horn logic, and rewriting logic reflective languages, as well as a variety of reflective theorem proving systems are placed within a common theoretical framework. General axioms for computational strategies, and for the internalization of those strategies in a reflective logic are also given. 1 Introduction Reflection is a fundamental idea. In logic it has been vigorously pursued by many researchers since the fundamental wor...

this paper I briefly sketch recent work on meta-logical foundations that seems promising as a conceptual basis on which to achieve the goal of formal interoperability. Specificaly, I will briefly discuss:

Run-time type analysis is an increasingly important linguistic mechanism in modern programming languages. Language runtime systems use it to implement services such as accurate garbage collection, serialization, cloning and structural equality. Component frameworks rely on it to provide reflection mechanisms so they may discover and interact with program interfaces dynamically. Run-time type analysis is also crucial for large, distributed systems that must be dynamically extended, because it allows those systems to check program invariants when new code and new forms of data are added. Finally, many generic user-level algorithms for iteration, pattern matching, and unification can be defined through type analysis mechanisms. However, existing frameworks for run-time type analysis were designed for simple type systems. They do not scale well to the sophisticated type systems of modern and next-generation programming languages that include complex constructs such as first-class abstract types, recursive types, objects, and type parameterization. In addition, facilities to support type analysis often require complicated

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.

Compile-time meta-programming allows programs to be constructed by the user at compile-time. Although LISP derived languages have long had such facilities, few modern languages are capable of compile-time meta-programming, and of those that do many of the most powerful are statically typed functional languages. In this paper I present the dynamically typed object orientated language Converge which allows compile-time meta-programming in the spirit of Template Haskell. Converge demonstrates that integrating powerful, safe compile-time meta-programming features into a dynamic language requires few restrictions to the flexible development style facilitated by the paradigm. In this paper I detail Converge’s compile-time meta-programming facilities, much of which is adapted from Template Haskell, contain several features new to the paradigm. Finally I explain how such a facility might be integrated into similar languages. 1.

Abstract. With the emergence of distributed component-based technologies, information services have become extremely modular and autonomous. This autonomy has allowed organizations within one enterprise to develop component-based solutions that are independent and perform tasks relevant to their domain-specific functionality. However, enterprise-level operations typically require the workflow composition of these independent services to accomplish corporate-wide goals. In traditional development environments, enterprises have taken a “top-down ” approach where the workflow was conceptualized and supporting low-level services have been created. This solution neglects the robustness and reuse associated with current distributed component-based technologies. In this work, there is a “bottom-up ” approach where existing component-based services can be composed to conform to a user-specified workflow. This paper presents an agent architecture that acts as an adaptive middleware-layer between existing components. This architecture accepts workflow specifications in the Unified Modeling Language as input to

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.

Abstract. Dynamic adaptation has become an essential feature in distributed applications, mainly because current technology enables complex tasks to be performed by computers in application domains unsuited for service interruption. This paper presents an infrastructure that uses an interpreted language to provide simple but powerful features that enable coarse and fine-grained adaptations in component-based systems, using the CORBA Component Model (CCM) as a basis. To extend the static nature of CCM, we propose dynamic containers, which enable development of dynamically adaptable components that admit changes on component structure and implementation. The extended set of mechanisms for component manipulation can be used to create adaptation abstractions that simplify the programmer’s task. In this paper, we present a tool that provides support for the protocols and roles abstractions, which allows programmers to adapt running applications, establishing new interactions among its components. 1

A reflective approach for modeling and implementing authorization systems is presented. The advantages of the combined use of computational reflection and authorization mechanisms are discussed, and three reflective architectures are examined for pointing out the corresponding merits and defects. Keywords: Authorization, Object-Orientation, Distributed Objects, Reflection, Security. 1 Introduction Security implies not only protection from external intrusions but also controllingthe actions of internal executing entities and the operations of the whole software system. In this case, the interleaving between operations and data secrecy may become very complicated and often intractable. For this reason security must be specified and designed in a system from its early design steps [9]. From another point of view ffl it is very important that the security mechanisms of the application be correct and stable; ffl the security code should not be mixed with the application code, otherwise it...

In the first part, we introduce binary representations of both lambda calculus and combinatory logic terms, and demonstrate their simplicity by providing very compact parser-interpreters for these binary languages. Along the way we also present new results on list representations, bracket abstraction, and fixpoint combinators. In the second part we review Algorithmic Information Theory, for which these interpreters provide a convenient vehicle. We demonstrate this with several concrete upper bounds on program-size complexity, including an elegant self-delimiting code for binary strings. 1