Compile-time meta-programming allows programs to be constructed by the user at compile-time. 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 compiletime meta-programming features into a dynamic language requires few restrictions to the flexible development style facilitated by the paradigm.

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...

philosophy to examine what sort of self-awareness the Grid needs. Several influential Grid researchers have said that the Grid requires selfaware systems, without saying explicitly what "self-aware " means. We classify definitions of self-awareness from philosophy, cognitive science and computer science into two families. The first family is concerned with the external behaviour of the system, the second with its internal processes and structure. The commonest computer science definition is in the second family, and involves reflection- the ability of a program to manipulate as data something representing the state of the program during its own execution. We argue, with examples, that reflection is not necessary for the Grid: Grid systems should use self-awareness properties based on the external behaviour of the system, or no self-awareness at all, depending on the task.

Abstract. One of the main factors driving object-oriented software development for information systems is the requirement for systems to be tolerant to change. To address this issue in designing systems, this paper proposes a pattern-based, object-oriented, description-driven system (DDS) architecture as an extension to the standard UML four-layer meta-model. A DDS architecture is proposed in which aspects of both static and dynamic systems behavior can be captured via descriptive models and meta-models. The proposed architecture embodies four main elements-firstly, the adoption of a multi-layered meta-modeling architecture and reflective meta-level architecture, secondly the identification of four data modeling relationships that can be made explicit such that they can be modified dynamically, thirdly the identification of five design patterns which have emerged from practice and have proved essential in providing reusable building blocks for data management, and fourthly the encoding of the structural properties of the five design patterns by means of one fundamental pattern, the Graph pattern. A practical example of this philosophy, the CRISTAL project, is used to demonstrate the use of description-driven data objects to handle system evolution.

this paper applications of reflection in rewriting logic and Maude to the following areas:

Physicalism is an ideology that contends that, in the last instance, all the entities in the world are physical and that the things people usually consider as being non-physical or mental are in-effect not more than a lasting phantasmagoria. Copernicus taught us that Man’s Earth was not the center of the universe; he showed that what was common sense and the conclusion of simple observation (that the sun rotates around the earth) was actually not the case. Copernicus showed that Man has a less significant role in space-time than he would like to have; he is pushed to an auxiliary orbit. Physicalism aims at a second Copernican revolution – it de-centers Man even further; it tries to teach us that cognitive human activity is not a special phenomenon: it is merely a specific chemical-biological arrangement of matter that to some misinformed people creates an illusion of a categorically different sphere which they call the ‘mental’. A serious investigation should supposedly free us of this folly and show us that what we call ‘mental ’ is simply either a higher-level description of the physical, an auxiliary effect of it, or that it is syntactic sugar for describing the physical itself. Physicalism claims that you, I, and all the other people we ever met are all physical chunks of matter. So is our consciousness, our causal mental powers, our intentional mental states (memories, thoughts, concepts, feelings, beliefs, desires, etc…) our virtues and morals, our ability to learn new things and our bodily sensations. The memory of your first kiss, the aptitude to play 1 I’m indebted to Professor Richard Boyd for useful comments on earlier drafts of this paper. Shay David

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...

Reflection has a long history of dealing about some aspects of software components. In this short position paper, we compare and contrast reflection and aspect-oriented programming. Whilst reflection has recently focused on very specific aspects of software components, namely implementational usually segregated among structural (representation) and behavioral (execution) aspects, aspect-oriented programming wishes to broaden the spectrum of attributes of software taken into account. On the other hand, weaving the aspects into a coherent and faithful implementation of their prescriptions is by nature a reflective process which can be put into the hand of aspect-oriented programmers using reflection. Finally, a link can be made between aspect-oriented programming and the underinvestigated area of declarative reflection. 1 Context During the last fifteen years, we have been involved in research on reflection in programming languages. Our contributions encompass: 1. object-orien...

As the size and complexity of software systems increase, a relevant part of the system overall functionality shifts from the applicative domain to run-time system management activities, i.e., management activities which cannot be performed off-line. These range from monitoring to dynamic reconfiguration and, for non-stopping systems, also include evolution, i.e., addition or replacement of components or entire subsystems. In current practice, run-time system management is impeded by the fact that the knowledge of the overall structure and functioning of the system (i.e., its software architecture) is confined in design specification documents, while it is only implicit in running systems. In this paper we introduce, provide rationale for, and briefly demonstrate an approach to system management where the system maintains, and operates on, an architectural description of itself. This description is causally connected to the system's concrete structure and state, i.e., any change of the system architecture affects the description, and vice versa. This model can be said to extend the principles of computational reflection from the realm of programming-in-the-small to that of programming-in-thelarge. Keywords: Reflection, Layered Systems, Software Architecture, Software Components, System Management. I.

This report thus describes initial work towards a clean definition of the semantics of reflection in both a high-level and low-level language. Although the pieces have not yet been tied completely together, the following results have been attained at this point in the project: