This paper introduces the basic concepts of the rewriting logic language Maude and discusses its implementation. Maude is a wide-spectrum language supporting formal specification, rapid prototyping, and parallel programming. Maude's rewriting logic paradigm includes the functional and object-oriented paradigms as sublanguages. The fact that rewriting logic is reflective leads to novel metaprogramming capabilities that can greatly increase software reusability and adaptability. Control of the rewriting computation is achieved through internal strategy languages defined inside the logic. Maude's rewrite engine is designed with the explicit goal of being highly extensible and of supporting rapid prototyping and formal methods applications, but its semi-compilation techniques allow it to meet those goals with good performance. 1 Introduction Maude is a logical language based on rewriting logic [16,23,19]. It is therefore related to other rewriting logic languages such as Cafe [10], ELAN [...

. This paper surveys the work of many researchers on rewriting logic since it was first introduced in 1990. The main emphasis is on the use of rewriting logic as a semantic framework for concurrency. The goal in this regard is to express as faithfully as possible a very wide range of concurrency models, each on its own terms, avoiding any encodings or translations. Bringing very different models under a common semantic framework makes easier to understand what different models have in common and how they differ, to find deep connections between them, and to reason across their different formalisms. It becomes also much easier to achieve in a rigorous way the integration and interoperation of different models and languages whose combination offers attractive advantages. The logic and model theory of rewriting logic are also summarized, a number of current research directions are surveyed, and some concluding remarks about future directions are made. Table of Contents 1 In...

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:

perty of rewriting logic is its reflective character [4]. We view reflection as a key feature of mobile computing, because mobile computations typically involve different computations occurring at possibly different sites that need good metalevel ways of communicating with each other, and also because of the modular and composable way in which issues like security and fault tolerance can be approached with reflective techniques. Reflection and security models are further discussed in subsequent sections. We sketch here an impressionistic account of how rewriting logic models concurrent systems. Rewriting logic is a logic to reason correctly about the evolution in time of a concurrent system. The distributed state of a concurrent system is represented as a term whose subterms represent the different components of the concurrent state. Typically, however, the structure of the concurrent state may have a variety of equivalent term representations because it

1 Introduction The current, and quite real, technical problems blocking software compositionality in practice could benefit from formal foundations providing clear semantics, new architecture and software composition methods, and better languages. The choice of foundations is however a delicate matter, because the proposed semantic framework should explictly address and support key features such as openness, distribution, object-orientation, compositionality, and mobility. Rewriting logic is a promising semantic framework supporting such key features and offering simple and rigorous formal foundations for software composition and evolution. It also provides a wide-spectrum approach in which architectural descriptions, executable formal specifications, and distributed and mobile code can be related, composed, transformed, and integrated in a rigorous way. Reflection is a key feature of rewriting logic of great usefulness for software composition, dynamicity, and mobility.

In this note, we report on some work in progress on using rewriting logics for discrete event simulation. The idea is to combine the proofs in the logic with the observations in the simulations to gain a better understanding of the interaction intricacies that seem to occur in complex simulations. In particular, we use communication protocols as our application domain, since they have all the interaction and unpredictability that makes formal specifications difficult. 1 Problem: Formal Methods in Simulation The historical barriers to the use of formal methods in designing and developing communication protocols derive from their different attitudes: verification models have been used for many years for proofs of behavior (a verification model cannot tell you when the model is wrong), but simulation models are used for observations of behavior (a simulation model cannot tell you when the model is right). These are almost always different models, since they must concentrate on different ...

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